diff --git a/.storybook/preview.js b/.storybook/preview.js index 8167dd5c380..ef0c86d3545 100644 --- a/.storybook/preview.js +++ b/.storybook/preview.js @@ -28,6 +28,9 @@ window.___navigate = (pathname) => { export const parameters = { actions: { argTypesRegex: "^on[A-Z].*" }, + backgrounds: { + disable: true, + }, controls: { matchers: { color: /(background|color)$/i, diff --git a/package.json b/package.json index 1a8047bd7b8..6894990e7cf 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "ethereum-org-website", - "version": "7.14.2", + "version": "7.15.0", "description": "Website of ethereum.org", "main": "index.js", "repository": "git@github.com:ethereum/ethereum-org-website.git", diff --git a/plugins/gatsby-remark-fix-static-urls/index.js b/plugins/gatsby-remark-fix-static-urls/index.js index 48c16332c72..506f4f64213 100644 --- a/plugins/gatsby-remark-fix-static-urls/index.js +++ b/plugins/gatsby-remark-fix-static-urls/index.js @@ -1,3 +1,4 @@ +const fs = require("fs") const path = require("path") const visitWithParents = require("unist-util-visit-parents") const isRelativeUrl = require("is-relative-url") @@ -39,7 +40,10 @@ module.exports = ({ markdownNode, markdownAST }) => { return } - node.url = path.join(relativePath, node.url) + // only modify the paths for those files doesn't exist in the current folder + if (!fs.existsSync(path.join(fileAbsoluteDir, node.url))) { + node.url = path.join(relativePath, node.url) + } } }) diff --git a/redirects.json b/redirects.json index 5e4a27fe380..785c04ada39 100644 --- a/redirects.json +++ b/redirects.json @@ -255,10 +255,6 @@ "fromPath": "/upgrades", "toPath": "/en/roadmap" }, - { - "fromPath": "/quizzes", - "toPath": "/en/quizzes/" - }, { "fromPath": "/*/upgrades", "toPath": "/:splat/roadmap" diff --git a/src/@chakra-ui/gatsby-plugin/components/Button.ts b/src/@chakra-ui/gatsby-plugin/components/Button.ts index 69d77204d14..6fc4bff049b 100644 --- a/src/@chakra-ui/gatsby-plugin/components/Button.ts +++ b/src/@chakra-ui/gatsby-plugin/components/Button.ts @@ -113,7 +113,7 @@ export const Button = defineStyleConfig({ baseStyle, sizes: defineMergeStyles(defaultSizes, { md: { - h: "42px", + h: 10.5, }, }), variants: { diff --git a/src/@chakra-ui/gatsby-plugin/components/Checkbox.ts b/src/@chakra-ui/gatsby-plugin/components/Checkbox.ts index 9cc3482127f..b4ffac6492e 100644 --- a/src/@chakra-ui/gatsby-plugin/components/Checkbox.ts +++ b/src/@chakra-ui/gatsby-plugin/components/Checkbox.ts @@ -1,70 +1,45 @@ import { createMultiStyleConfigHelpers, defineStyle } from "@chakra-ui/react" import { checkboxAnatomy } from "@chakra-ui/anatomy" -import { checkboxDefaultTheme, defineMergeStyles } from "./components.utils" +import { + checkboxDefaultTheme, + commonInputTriggerStyles, + defineMergeStyles, +} from "./components.utils" -const { baseStyle: defaultBaseStyle } = checkboxDefaultTheme +const { sizes: defaultSizes } = checkboxDefaultTheme const { definePartsStyle, defineMultiStyleConfig } = createMultiStyleConfigHelpers(checkboxAnatomy.keys) -const baseStyleControl = defineStyle((props) => - defineMergeStyles(defaultBaseStyle?.(props).control, { - bg: "background.base", - _checked: { - bg: "primary400", - _hover: { - bg: "primary400", - borderColor: "primary600", - }, - borderColor: "black50", - }, - border: "1px", - borderColor: "black50", - borderRadius: "3px", - transition: "all 150ms", - _focusVisible: { - boxShadow: "none", - }, - _hover: { - boxShadow: "tableItemBoxShadow", - border: "1px", - borderStyle: "solid", - borderColor: "primary600", - transition: "transform 0.1s", - transform: "scale(1.02)", - }, - }) +const { commonContainerProps, commonControlProps, commonLabelProps } = + commonInputTriggerStyles + +const checkboxMdSize = defaultSizes?.md + +const baseStyleControl = defineMergeStyles( + checkboxMdSize?.control, + commonControlProps, + { + boxSize: "var(--checkbox-size)", // Comes from default theme + borderRadius: "sm", + } ) -const sizes = { - md: defineStyle({ - control: { - h: "1.5rem", - w: "1.5rem", - }, - icon: { - fontSize: "md", - }, - }), -} +const baseStyleLabel = defineStyle({ ...commonLabelProps }) + +const baseStyleContainer = defineStyle({ ...commonContainerProps }) + +const baseStyleIcon = defineStyle({ + boxSize: 2, +}) -const variantAlignTop = definePartsStyle({ - control: { - mt: "0.25rem", - }, +const baseStyle = definePartsStyle({ + container: baseStyleContainer, + control: baseStyleControl, + label: baseStyleLabel, + icon: baseStyleIcon, }) export const Checkbox = defineMultiStyleConfig({ - baseStyle: definePartsStyle((props) => ({ - ...defaultBaseStyle?.(props), - control: baseStyleControl(props), - })), - sizes, - variants: { - // TODO: remove this variant - alignTop: variantAlignTop, - }, - defaultProps: { - size: "md", - }, + baseStyle, }) diff --git a/src/@chakra-ui/gatsby-plugin/components/Input.ts b/src/@chakra-ui/gatsby-plugin/components/Input.ts new file mode 100644 index 00000000000..510a6205d55 --- /dev/null +++ b/src/@chakra-ui/gatsby-plugin/components/Input.ts @@ -0,0 +1,117 @@ +import { inputAnatomy } from "@chakra-ui/anatomy" +import { + createMultiStyleConfigHelpers, + defineStyle, +} from "@chakra-ui/styled-system" +import { defineMergeStyles, inputDefaultTheme } from "./components.utils" + +const { defineMultiStyleConfig, definePartsStyle } = + createMultiStyleConfigHelpers(inputAnatomy.keys) + +const baseStyle = definePartsStyle((props) => { + const { + focusBorderColor: fc = "primaryHover", + errorBorderColor: ec = "errorOutline", + } = props + + return defineMergeStyles( + inputDefaultTheme.baseStyle, + inputDefaultTheme.variants?.outline(props), + { + field: { + borderColor: "currentColor", + borderRadius: "base", + outline: "3px solid transparent", + lineHeight: 1, + _placeholder: { + color: "disabled", + opacity: 1, + }, + _focusVisible: { + outlineColor: fc, + outlineOffset: "-1px", + borderColor: "transparent", + boxShadow: "none", + }, + _hover: null, // override default + _groupHover: { + borderColor: "primary.hover", + }, + _invalid: { + borderColor: ec, + boxShadow: "none", + }, + _disabled: { + borderColor: "disabled", + opacity: 1, + }, + "&:not(:disabled)": { + _active: { + bg: "background.highlight", + borderColor: "primary.highContrast", + }, + }, + }, + element: { + fontSize: "2xl", + transitionProperty: "common", + transitionDuration: "normal", + _groupHover: { + color: "primary.hover", + }, + _peerFocusVisible: { + color: fc, + _peerInvalid: { + color: ec, + }, + _peerDisabled: { + color: "disabled", + }, + }, + _peerDisabled: { + color: "disabled", + }, + "[data-peer]:not(:disabled):active ~ &": { + color: "primary.dark", + _dark: { + color: "primary.highContrast", + }, + }, + }, + } + ) +}) + +const size = { + md: defineStyle({ + h: 10.5, + px: 2, + }), + sm: defineStyle({ + h: 8, + px: 1, + }), +} + +const sizes = { + md: definePartsStyle({ + field: size.md, + element: size.md, + }), + sm: definePartsStyle({ + field: { ...size.sm, fontSize: "sm" }, + element: { + ...size.sm, + fontSize: "xl", + }, + }), +} + +export const Input = defineMultiStyleConfig({ + baseStyle, + sizes, + defaultProps: { + variant: "outline", + size: "md", + }, +}) diff --git a/src/@chakra-ui/gatsby-plugin/components/Radio.ts b/src/@chakra-ui/gatsby-plugin/components/Radio.ts new file mode 100644 index 00000000000..85d6a872164 --- /dev/null +++ b/src/@chakra-ui/gatsby-plugin/components/Radio.ts @@ -0,0 +1,51 @@ +import { + createMultiStyleConfigHelpers, + cssVar, + defineStyle, +} from "@chakra-ui/react" +import { radioAnatomy } from "@chakra-ui/anatomy" +import { + commonInputTriggerStyles, + defineMergeStyles, + radioDefaultTheme, +} from "./components.utils" + +const { defineMultiStyleConfig, definePartsStyle } = + createMultiStyleConfigHelpers(radioAnatomy.keys) + +export const $radioDisableColor = cssVar("radio-disable-color") + +const { commonContainerProps, commonControlProps, commonLabelProps } = + commonInputTriggerStyles + +const baseStyleContainer = defineStyle({ ...commonContainerProps }) + +const baseStyleControl = defineMergeStyles( + radioDefaultTheme.baseStyle?.({} as never).control, + commonControlProps, + { + boxSize: 4, + fontSize: "md", + "*:hover > &": { + outlineOffset: "-1px", + }, + _checked: { + _before: { + // Force half the size, as '50%' value not reliable. + boxSize: 2, + }, + }, + } +) + +const baseStyleLabel = defineStyle({ ...commonLabelProps }) + +const baseStyle = definePartsStyle({ + container: baseStyleContainer, + control: baseStyleControl, + label: baseStyleLabel, +}) + +export const Radio = defineMultiStyleConfig({ + baseStyle, +}) diff --git a/src/@chakra-ui/gatsby-plugin/components/Select.ts b/src/@chakra-ui/gatsby-plugin/components/Select.ts new file mode 100644 index 00000000000..4a07cc0cd84 --- /dev/null +++ b/src/@chakra-ui/gatsby-plugin/components/Select.ts @@ -0,0 +1,77 @@ +import { selectAnatomy } from "@chakra-ui/anatomy" +import { createMultiStyleConfigHelpers, cssVar } from "@chakra-ui/react" +import { defineMergeStyles, selectDefaultTheme } from "./components.utils" +import { Input as inputTheme } from "./Input" + +const { baseStyle: inputBaseStyles } = inputTheme + +const baseFieldStyles = inputBaseStyles?.({} as never).field + +const { defineMultiStyleConfig, definePartsStyle } = + createMultiStyleConfigHelpers(selectAnatomy.keys) + +const baseStyleField = defineMergeStyles(selectDefaultTheme.baseStyle?.field, { + ...baseFieldStyles, + cursor: "pointer", + py: 2, + ps: 2, + pe: 8, + h: 10.5, + _focusVisible: { + outline: "3px solid", + outlineColor: "primary.hover", + outlineOffset: "-1px", + }, + "&:not(:disabled)": { + _hover: { + ...baseFieldStyles?.["&:not(:disabled)"], + boxShadow: "buttonHover", + }, + }, +}) + +const baseStyleIcon = defineMergeStyles(selectDefaultTheme.baseStyle?.icon, { + _peerHover: { + color: "primary.base", + }, +}) + +const baseStyle = definePartsStyle({ + field: baseStyleField, + icon: baseStyleIcon, +}) + +const variantOutline = definePartsStyle({ + field: { + borderRadius: "base", + }, +}) + +const flushedBorderColor = "transparent !important" + +const variantFlushed = definePartsStyle({ + field: { + borderBottomRadius: 0, + borderTopColor: flushedBorderColor, + borderInlineColor: flushedBorderColor, + "&:not(:disabled)": { + _hover: { + borderTopColor: flushedBorderColor, + borderInlineColor: flushedBorderColor, + }, + }, + }, +}) + +const variants = { + outline: variantOutline, + flushed: variantFlushed, +} + +export const Select = defineMultiStyleConfig({ + baseStyle, + variants, + defaultProps: { + variant: "outline", + }, +}) diff --git a/src/@chakra-ui/gatsby-plugin/components/Switch.ts b/src/@chakra-ui/gatsby-plugin/components/Switch.ts new file mode 100644 index 00000000000..e3b2d5a8bce --- /dev/null +++ b/src/@chakra-ui/gatsby-plugin/components/Switch.ts @@ -0,0 +1,66 @@ +import { createMultiStyleConfigHelpers } from "@chakra-ui/react" +import { switchAnatomy } from "@chakra-ui/anatomy" +import { + commonInputTriggerStyles, + defineMergeStyles, + switchDefaultTheme, + _notDisabledReadOnly, +} from "./components.utils" + +const { defineMultiStyleConfig, definePartsStyle } = + createMultiStyleConfigHelpers(switchAnatomy.keys) + +const { baseStyle: defaultBaseStyle, sizes: defaultSizes } = switchDefaultTheme + +const switchSmSize = defaultSizes?.sm + +const { commonControlProps, commonContainerProps, commonLabelProps } = + commonInputTriggerStyles + +const baseStyleContainer = defineMergeStyles( + defaultBaseStyle?.({} as never).container, + switchSmSize?.container, + commonContainerProps +) + +const baseStyleThumb = defineMergeStyles( + defaultBaseStyle?.({} as never).thumb, + { + bg: "background.base", + [".chakra-switch__track:not([data-checked])[data-disabled] > &"]: { + border: "1px", + borderColor: "disabled", + }, + } +) + +const baseStyleTrack = defineMergeStyles( + defaultBaseStyle?.({} as never).track, + commonControlProps, + { + bg: "body.medium", + borderColor: "transparent", + _invalid: { borderColor: "error.outline" }, + _focusVisible: { bg: "gray.500", borderColor: "transparent" }, + ["&:not([data-checked])[data-disabled]"]: { + bg: "transparent", + borderColor: "disabled", + }, + [_notDisabledReadOnly]: { + "*[data-checked]:hover > &, *:not([data-checked]):hover > &": { + bg: "primary.hover", + borderColor: "transparent", + }, + }, + } +) + +const baseStyle = definePartsStyle({ + container: baseStyleContainer, + thumb: baseStyleThumb, + track: baseStyleTrack, +}) + +export const Switch = defineMultiStyleConfig({ + baseStyle, +}) diff --git a/src/@chakra-ui/gatsby-plugin/components/components.utils.ts b/src/@chakra-ui/gatsby-plugin/components/components.utils.ts index 3016b7964c6..fdf3be4dc14 100644 --- a/src/@chakra-ui/gatsby-plugin/components/components.utils.ts +++ b/src/@chakra-ui/gatsby-plugin/components/components.utils.ts @@ -1,4 +1,4 @@ -import { SystemStyleObject, theme } from "@chakra-ui/react" +import { cssVar, SystemStyleObject, theme } from "@chakra-ui/react" import { merge } from "lodash" const { @@ -20,6 +20,7 @@ const { List: listDefaultTheme, Menu: menuDefaultTheme, Modal: modalDefaultTheme, + Radio: radioDefaultTheme, Select: selectDefaultTheme, Spinner: spinnerDefaultTheme, Switch: switchDefaultTheme, @@ -47,6 +48,7 @@ export { listDefaultTheme, menuDefaultTheme, modalDefaultTheme, + radioDefaultTheme, selectDefaultTheme, spinnerDefaultTheme, switchDefaultTheme, @@ -70,3 +72,66 @@ export function defineMergeStyles( ): Record { return merge(defaultTheming, ...styleObjs) } + +export const _notDisabledReadOnly = + "&:not([data-disabled], [disabled], [data-readonly])" + +const $inputTriggerDisableColor = cssVar("input-trigger-disable-color") + +export const commonInputTriggerStyles = { + commonControlProps: { + border: "1px", + borderColor: "body.medium", + outline: "3px solid", + outlineColor: "transparent", + _checked: { + color: "background.base", + bg: "primary.base", + borderColor: "primary.base", + }, + _focusVisible: { + borderColor: "primary.highContrast", + outlineColor: "primary.hover", + outlineOffset: "2px", + boxShadow: "none", + }, + _disabled: { + bg: $inputTriggerDisableColor.reference, + borderColor: $inputTriggerDisableColor.reference, + opacity: 1, + _checked: { + bg: $inputTriggerDisableColor.reference, + borderColor: $inputTriggerDisableColor.reference, + }, + }, + [_notDisabledReadOnly]: { + // Hovering over the label triggers the style for the control + "*[data-checked]:hover > &": { + bg: "primary.hover", + borderColor: "primary.highContrast", + }, + "*:not([data-checked]):hover > &": { + bg: "body.light", + borderColor: "primary.highContrast", + }, + }, + _invalid: { + // TODO: Investigate inconsistency in prop rendering order (possible Chakra bug) + // border: "2px", + borderColor: "error.base", + bg: "error.light", + }, + }, + commonContainerProps: { + [$inputTriggerDisableColor.variable]: "colors.disabled", + ["[data-disabled], [disabled], [data-readonly]"]: { + cursor: "not-allowed", + }, + }, + commonLabelProps: { + _disabled: { + color: $inputTriggerDisableColor.reference, + opacity: 1, + }, + }, +} diff --git a/src/@chakra-ui/gatsby-plugin/components/index.ts b/src/@chakra-ui/gatsby-plugin/components/index.ts index 2c50a181458..f70aeb29f14 100644 --- a/src/@chakra-ui/gatsby-plugin/components/index.ts +++ b/src/@chakra-ui/gatsby-plugin/components/index.ts @@ -6,6 +6,10 @@ import { Modal } from "./Modal" import { Checkbox } from "./Checkbox" import { Progress } from "./Progress" import { Tabs } from "./Tabs" +import { Radio } from "./Radio" +import { Select } from "./Select" +import { Switch } from "./Switch" +import { Input } from "./Input" import { accordionDefaultTheme, avatarDefaultTheme, @@ -18,9 +22,7 @@ import { formLabelDefaultTheme, headingDefaultTheme, menuDefaultTheme, - selectDefaultTheme, spinnerDefaultTheme, - switchDefaultTheme, tableDefaultTheme, } from "./components.utils" @@ -38,13 +40,15 @@ export default { Form: formDefaultTheme, FormLabel: formLabelDefaultTheme, Heading: headingDefaultTheme, + Input, Link, Menu: menuDefaultTheme, Modal, Progress, - Select: selectDefaultTheme, + Radio, + Select, Spinner: spinnerDefaultTheme, - Switch: switchDefaultTheme, + Switch, Table: tableDefaultTheme, Tabs, Tag, diff --git a/src/@chakra-ui/gatsby-plugin/foundations/index.ts b/src/@chakra-ui/gatsby-plugin/foundations/index.ts index 33f602c127d..2756e138558 100644 --- a/src/@chakra-ui/gatsby-plugin/foundations/index.ts +++ b/src/@chakra-ui/gatsby-plugin/foundations/index.ts @@ -1,6 +1,7 @@ import colors from "./colors" import shadows from "./shadows" import typography from "./typography" +import spacing from "./spacing" import sizes from "./sizes" // Check the following link to see all the possible options: @@ -8,8 +9,12 @@ import sizes from "./sizes" const foundations = { colors, shadows, + space: spacing, + sizes: { + ...spacing, + ...sizes, + }, ...typography, - sizes, } export default foundations diff --git a/src/@chakra-ui/gatsby-plugin/foundations/spacing.ts b/src/@chakra-ui/gatsby-plugin/foundations/spacing.ts new file mode 100644 index 00000000000..b1c918a4759 --- /dev/null +++ b/src/@chakra-ui/gatsby-plugin/foundations/spacing.ts @@ -0,0 +1,6 @@ +const spacing = { + 7.5: "1.875rem", + 10.5: "2.625rem", +} + +export default spacing diff --git a/src/@chakra-ui/gatsby-plugin/semanticTokens.ts b/src/@chakra-ui/gatsby-plugin/semanticTokens.ts index 03536b45ecf..7ce725ce478 100644 --- a/src/@chakra-ui/gatsby-plugin/semanticTokens.ts +++ b/src/@chakra-ui/gatsby-plugin/semanticTokens.ts @@ -101,6 +101,12 @@ const semanticTokens = { "linear-gradient(102.7deg, rgba(185, 185, 241, 0.2) 0%, rgba(84, 132, 234, 0.2) 51.56%, rgba(58, 142, 137, 0.2) 100%)", }, }, + shadows: { + buttonHover: { + _light: "4px 4px 0 var(--eth-colors-blue-100)", + _dark: "4px 4px 0 #352313", + }, + }, } export default semanticTokens diff --git a/src/components/ActionCard.tsx b/src/components/ActionCard.tsx index c953373d703..e0761396237 100644 --- a/src/components/ActionCard.tsx +++ b/src/components/ActionCard.tsx @@ -9,6 +9,7 @@ import { LinkOverlay, Image, useColorModeValue, + LinkBoxProps, } from "@chakra-ui/react" import { GatsbyImage, IGatsbyImageData } from "gatsby-plugin-image" @@ -26,7 +27,7 @@ const linkFocusStyles: BoxProps = { textDecoration: "none", } -export interface IProps { +export interface IProps extends Omit { children?: React.ReactNode to: string alt?: string @@ -48,6 +49,7 @@ const ActionCard: React.FC = ({ className, isRight, isBottom = true, + ...rest }) => { const isImageURL = typeof image === "string" const descriptionColor = useColorModeValue("blackAlpha.700", "whiteAlpha.800") @@ -63,6 +65,7 @@ const ActionCard: React.FC = ({ _focus={linkBoxFocusStyles} className={className} m={4} + {...rest} > = { + title: "Atoms / Form / Checkbox", + component: CheckboxComponent, + parameters: { + controls: { + hideNoControlsWarning: true, + expanded: false, + }, + }, +} + +export default meta + +type Story = StoryObj + +const DEFAULT_VAL = "checked" + +export const Checkbox: Story = { + render: () => ( + + + defaultValue + + isDisabled + + + isFocusable + + + isReadOnly + + + isRequired + + + isInvalid + + + + ), +} diff --git a/src/components/BaseStories/Radio.stories.tsx b/src/components/BaseStories/Radio.stories.tsx new file mode 100644 index 00000000000..6df29547968 --- /dev/null +++ b/src/components/BaseStories/Radio.stories.tsx @@ -0,0 +1,62 @@ +import * as React from "react" +import { RadioGroup, Radio as RadioComponent, Flex } from "@chakra-ui/react" +import { Meta, StoryObj } from "@storybook/react" + +type RadioType = typeof RadioComponent + +const meta: Meta = { + title: "Atoms / Form / Radio", + component: RadioComponent, + argTypes: { + flexDirection: { + options: ["column", "row"], + control: { type: "radio" }, + }, + }, + parameters: { + controls: { + hideNoControlsWarning: true, + expanded: false, + }, + }, +} + +export default meta + +type Story = StoryObj + +export const Radio: Story = { + args: { + flexDirection: "column", + }, + argTypes: { + value: { + options: ["checked", "disabled", "focusable", "read-only", "required"], + control: { + type: "radio", + }, + }, + }, + render: ({ flexDirection, value }) => ( + + + defaultValue + + isDisabled + + + isFocusable and disabled + + + isReadOnly + + + isRequired + + + isInvalid + + + + ), +} diff --git a/src/components/BaseStories/Switch.stories.tsx b/src/components/BaseStories/Switch.stories.tsx new file mode 100644 index 00000000000..832573f3017 --- /dev/null +++ b/src/components/BaseStories/Switch.stories.tsx @@ -0,0 +1,41 @@ +import * as React from "react" +import { SimpleGrid, Switch as SwitchComponent } from "@chakra-ui/react" +import { Meta, StoryObj } from "@storybook/react" + +type SwitchType = typeof SwitchComponent + +const meta: Meta = { + title: "Atoms / Form / Switch", + component: SwitchComponent, + parameters: { + controls: { + hideNoControlsWarning: true, + expanded: false, + }, + }, +} + +export default meta + +type Story = StoryObj + +export const Switch: Story = { + render: () => ( + + isChecked: + + + isDisabled and checked: + + + isFocusable & isDisabled: + + + isReadOnly: + + + isRequired: + + + ), +} diff --git a/src/components/ButtonDropdown.tsx b/src/components/ButtonDropdown.tsx index 04f8a468f3a..c6a844f8fb6 100644 --- a/src/components/ButtonDropdown.tsx +++ b/src/components/ButtonDropdown.tsx @@ -1,99 +1,22 @@ // Libraries -import React, { useState, createRef } from "react" -import styled from "@emotion/styled" -import { motion } from "framer-motion" +import React, { MouseEvent } from "react" import { MdMenu } from "react-icons/md" +import { + Button, + ButtonProps, + Menu, + MenuButton, + MenuItem, + MenuList, +} from "@chakra-ui/react" // Components import Link from "./Link" -import Button from "./Button" import Translation from "./Translation" // Utils -import { useOnClickOutside } from "../hooks/useOnClickOutside" import { trackCustomEvent } from "../utils/matomo" -const Container = styled.div` - position: relative; - display: flex; - flex-direction: column; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - width: 100%; - flex-direction: column-reverse; - } -` - -const DropdownList = styled(motion.ul)` - min-width: 240px; - z-index: 2; - margin: 0; - margin-top: 0.25rem; - position: absolute; - list-style-type: none; - list-style-image: none; - top: 100%; - width: auto; - border-radius: 0.5em; - background: ${(props) => props.theme.colors.dropdownBackground}; - border: 1px solid ${(props) => props.theme.colors.text}; - padding-top: 0.5rem; - padding-bottom: 0.5rem; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - width: 100%; - text-align: center; - position: initial; - } -` - -const listVariants = { - open: { - opacity: 1, - rotateX: 0, - display: "block", - transition: { - duration: 0.2, - }, - }, - closed: { - opacity: 0, - rotateX: -15, - transitionEnd: { - display: "none", - }, - }, -} - -const DropdownItem = styled.li` - margin: 0; - color: ${(props) => props.theme.colors.text}; - &:hover { - color: ${(props) => props.theme.colors.primary}; - background: ${(props) => props.theme.colors.dropdownBackgroundHover}; - } -` - -const NavLink = styled(Link)` - text-decoration: none; - display: block; - padding: 0.5rem; - color: ${(props) => props.theme.colors.text}; - &:hover { - text-decoration: none; - color: ${(props) => props.theme.colors.primary}; - } -` - -const NakedNavLink = styled.div` - text-decoration: none; - display: block; - padding: 0.5rem; - color: ${(props) => props.theme.colors.text}; - cursor: pointer; - &:hover { - color: ${(props) => props.theme.colors.primary}; - } -` - export interface ListItem { text: string to?: string @@ -111,72 +34,86 @@ export interface List { items: Array } -export interface IProps { +export interface IProps extends ButtonProps { list: List - className?: string } -const ButtonDropdown: React.FC = ({ list, className }) => { - const [isOpen, setIsOpen] = useState(false) - const ref = createRef() +const ButtonDropdown: React.FC = ({ list, ...rest }) => { + const handleClick = ( + e: MouseEvent, + item: ListItem, + idx: number + ) => { + const { matomo, callback } = item - useOnClickOutside(ref, () => setIsOpen(false)) + if (matomo) { + trackCustomEvent(matomo) + } - // Toggle on `enter` key - const onKeyDownHandler = (e: React.KeyboardEvent): void => { - if (e.key === "13") { - setIsOpen(!isOpen) + if (callback) { + e.preventDefault() + callback(idx) } } - return ( - - - + - {list.items.map(({ text, to, matomo, callback }, idx) => ( - setIsOpen(false)}> - {!!to && !!matomo && ( - { - trackCustomEvent(matomo) + {list.items.map((item, idx) => { + const { text, to } = item + + return to ? ( + + handleClick(e, item, idx)} + p={2} + textAlign="center" + justifyContent="center" + bg="dropdownBackground" + _hover={{ + color: "primary.base", + bg: "dropdownBackgroundHover", + }} + _focus={{ + color: "primary.base", + bg: "dropdownBackgroundHover", }} - to={to} > - - )} - {!!to && !matomo && ( - - - - )} - {!!callback && ( - callback(idx)}> - - - )} - - ))} - - + + + ) : ( + handleClick(e, item, idx)}> + + + ) + })} + + ) } diff --git a/src/components/Checkbox.tsx b/src/components/Checkbox.tsx deleted file mode 100644 index 9745838f270..00000000000 --- a/src/components/Checkbox.tsx +++ /dev/null @@ -1,31 +0,0 @@ -import React from "react" -import { - Checkbox as ChakraCheckbox, - CheckboxProps, - Icon, - IconProps, -} from "@chakra-ui/react" - -const CustomIcon = (props: IconProps) => { - return ( - - - - ) -} - -export interface IProps extends CheckboxProps {} - -const Checkbox: React.FC = (props) => { - return } {...props} /> -} - -export default Checkbox diff --git a/src/components/DismissibleCard.tsx b/src/components/DismissibleCard.tsx deleted file mode 100644 index 013c0669a5c..00000000000 --- a/src/components/DismissibleCard.tsx +++ /dev/null @@ -1,64 +0,0 @@ -import React, { useState, useEffect } from "react" -import styled from "@emotion/styled" - -import Icon from "./Icon" - -const Card = styled.div<{ - shouldShow: boolean -}>` - display: ${(props) => (props.shouldShow ? `block` : `none`)}; - position: relative; - background: ${(props) => props.theme.colors.warning}; - padding: 1.5rem; - border-radius: 4px; - color: ${(props) => props.theme.colors.black300}; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - margin-bottom: 2rem; - } -` - -const CloseIconContainer = styled.span` - position: absolute; - cursor: pointer; - top: 1.5rem; - right: 1.5rem; - - & > svg { - fill: ${(props) => props.theme.colors.black300}; - } -` - -export interface IProps { - children?: React.ReactNode - storageKey: string -} - -const DismissibleCard: React.FC = ({ children, storageKey }) => { - const [shouldShow, setshouldShow] = useState(false) - - useEffect(() => { - if (localStorage && localStorage.getItem(storageKey) !== null) { - setshouldShow(false) - } else { - setshouldShow(true) - } - }, [storageKey]) - - const handleClose = () => { - if (localStorage) { - localStorage.setItem(storageKey, "true") - } - setshouldShow(false) - } - - return ( - - - - - {children} - - ) -} - -export default DismissibleCard diff --git a/src/components/EthPriceCard.tsx b/src/components/EthPriceCard.tsx index 9fac934fa81..37cd0eab666 100644 --- a/src/components/EthPriceCard.tsx +++ b/src/components/EthPriceCard.tsx @@ -1,5 +1,5 @@ import React, { useState, useEffect } from "react" -import { Box, Flex, Heading, Icon } from "@chakra-ui/react" +import { Box, Flex, FlexProps, Heading, Icon } from "@chakra-ui/react" import { MdInfoOutline } from "react-icons/md" import axios from "axios" @@ -7,13 +7,12 @@ import Translation from "./Translation" import Link from "./Link" import Tooltip from "./Tooltip" -export interface IProps { - className?: string +export interface IProps extends FlexProps { isLeftAlign?: boolean } // TODO add prop to left vs. center align -const EthPriceCard: React.FC = ({ className, isLeftAlign = false }) => { +const EthPriceCard: React.FC = ({ isLeftAlign = false, ...rest }) => { const [state, setState] = useState({ currentPriceUSD: "", percentChangeUSD: 0, @@ -75,7 +74,6 @@ const EthPriceCard: React.FC = ({ className, isLeftAlign = false }) => { return ( = ({ className, isLeftAlign = false }) => { maxW="420px" maxH="192px" borderRadius="base" + {...rest} > = ({ isChecked={ restProps.filters[option.filterKey!] } - size="md" width="full" onChange={handleClick} > diff --git a/src/components/FindWallet/WalletTable/useWalletTable.tsx b/src/components/FindWallet/WalletTable/useWalletTable.tsx index 5a24ede7496..7c2ba903c30 100644 --- a/src/components/FindWallet/WalletTable/useWalletTable.tsx +++ b/src/components/FindWallet/WalletTable/useWalletTable.tsx @@ -1,4 +1,3 @@ -import * as React from "react" import { Icon } from "@chakra-ui/react" import { useState } from "react" import { WalletTableProps } from "." @@ -32,7 +31,7 @@ export interface DropdownOption { icon: typeof Icon } -type ColumnClassName = "firstCol" | "secondCol" | "thirdCol" +export type ColumnClassName = "firstCol" | "secondCol" | "thirdCol" type UseWalletTableProps = Pick & { t: (x: string) => string diff --git a/src/components/HorizontalCard.tsx b/src/components/HorizontalCard.tsx index 0b65d42a124..4cf6db61571 100644 --- a/src/components/HorizontalCard.tsx +++ b/src/components/HorizontalCard.tsx @@ -2,10 +2,10 @@ import React, { ReactNode } from "react" import Emoji from "./Emoji" import { Text, Box, Flex, FlexProps } from "@chakra-ui/react" -export interface IProps extends FlexProps { +export interface IProps extends Omit { emoji: string + title: ReactNode description: ReactNode - className?: string emojiSize?: number } @@ -14,11 +14,10 @@ const HorizontalCard: React.FC = ({ title, description, children, - className, emojiSize, ...rest }) => ( - + {title} diff --git a/src/components/Input/Input.stories.tsx b/src/components/Input/Input.stories.tsx new file mode 100644 index 00000000000..b0e3ba5f33b --- /dev/null +++ b/src/components/Input/Input.stories.tsx @@ -0,0 +1,55 @@ +import * as React from "react" +import { VStack } from "@chakra-ui/react" +import { Meta, StoryObj } from "@storybook/react" +import Input from "." +import { MdSearch } from "react-icons/md" +import { BsSlashSquare } from "react-icons/bs" + +type InputType = typeof Input + +const meta: Meta = { + title: "Atoms / Form / Input", + component: Input, +} + +export default meta + +type Story = StoryObj + +export const Sizes: Story = { + render: () => ( + + } + rightElement={} + placeholder="Search" + /> + } + rightElement={} + placeholder="Search" + size="sm" + /> + + ), +} + +export const ElementVariations: Story = { + render: () => ( + + } + rightElement={} + placeholder="input text" + /> + } placeholder="input text" /> + + } placeholder="input text" /> + } + placeholder="input text" + isDisabled + /> + + ), +} diff --git a/src/components/Input/index.tsx b/src/components/Input/index.tsx new file mode 100644 index 00000000000..562fc96713f --- /dev/null +++ b/src/components/Input/index.tsx @@ -0,0 +1,40 @@ +import * as React from "react" +import { + Input as ChakraInput, + InputGroup, + InputGroupProps, + InputLeftElement, + InputProps as ChakraInputProps, + InputRightElement, +} from "@chakra-ui/react" + +interface InputProps extends ChakraInputProps { + /** + * The Element or Icon used to render `InputLeftElement` + */ + leftElement?: React.ReactNode + /** + * The Element or Icon used to render `InputRightElement` + */ + rightElement?: React.ReactNode + inputGroupProps?: InputGroupProps +} + +function Input(props: InputProps) { + if ("leftElement" in props || "rightElement" in props) { + const { size, inputGroupProps, leftElement, rightElement, ...rest } = props + return ( + + + {leftElement ? : null} + {rightElement ? : null} + + ) + } + + const { size, ...rest } = props + + return +} + +export default Input diff --git a/src/components/MatomoOptOut.tsx b/src/components/MatomoOptOut.tsx index 994bb3773f9..fc81841ad46 100644 --- a/src/components/MatomoOptOut.tsx +++ b/src/components/MatomoOptOut.tsx @@ -1,6 +1,6 @@ import React, { useState, useEffect } from "react" import { MATOMO_LS_KEY } from "../utils/matomo" -import { Checkbox, Flex, Text } from "@chakra-ui/react" +import { Flex, Checkbox, Text } from "@chakra-ui/react" export interface IProps {} @@ -53,12 +53,10 @@ const MatomoOptOut: React.FC = () => { "Loading preferences..." ) : ( {isOptedOut ? "You are opted out. Check this box to opt-in." diff --git a/src/components/MeetupList.tsx b/src/components/MeetupList.tsx index 14548e9c3d9..3dd038f1149 100644 --- a/src/components/MeetupList.tsx +++ b/src/components/MeetupList.tsx @@ -4,7 +4,6 @@ import { sortBy } from "lodash" import { Box, Flex, - Input, LinkBox, LinkOverlay, List, @@ -23,6 +22,7 @@ import Translation from "./Translation" // Data import meetups from "../data/community-meetups.json" +import Input from "./Input" // Utils import { trackCustomEvent } from "../utils/matomo" @@ -77,21 +77,9 @@ const MeetupList: React.FC = () => { return ( {/* hidden for attachment to input only */} diff --git a/src/components/ProductDisclaimer.tsx b/src/components/ProductDisclaimer.tsx new file mode 100644 index 00000000000..e1d7b6b6fc6 --- /dev/null +++ b/src/components/ProductDisclaimer.tsx @@ -0,0 +1,11 @@ +import React from "react" +import InfoBanner from "./InfoBanner" +import Translation from "./Translation" + +const ProductDisclaimer = () => ( + + + +) + +export default ProductDisclaimer diff --git a/src/components/Select/Select.stories.tsx b/src/components/Select/Select.stories.tsx new file mode 100644 index 00000000000..e749b95b8db --- /dev/null +++ b/src/components/Select/Select.stories.tsx @@ -0,0 +1,37 @@ +import * as React from "react" +import { VStack } from "@chakra-ui/react" +import { Meta, StoryObj } from "@storybook/react" +import SelectComponent from "./" + +const selectData = [ + { label: "Ethereum", value: "eth" }, + { label: "Bitcoin", value: "bit" }, + { label: "Dogecoin", value: "doge" }, +] + +type SelectType = typeof SelectComponent + +const meta: Meta = { + title: "Atoms / Form / Select", + component: SelectComponent, +} + +export default meta + +type Story = StoryObj + +export const Select: Story = { + args: { + minW: "223px", + options: selectData, + onChange(selectedOption) { + console.log(selectedOption) + }, + }, + render: (args) => ( + + + + + ), +} diff --git a/src/components/Select/index.tsx b/src/components/Select/index.tsx new file mode 100644 index 00000000000..fc9b7306c7b --- /dev/null +++ b/src/components/Select/index.tsx @@ -0,0 +1,81 @@ +import * as React from "react" +import { + Select as ChakraSelect, + SelectProps as ChakraSelectProps, + ThemingProps, +} from "@chakra-ui/react" + +interface SelectProps + extends Omit, + Pick, "variant"> { + defaultValue?: { label: string; value: string; [x: string]: any } + onChange(selectedOption: any | ""): void + placeholder?: string + options: Record[] +} + +const Select = (props: SelectProps) => { + const { options, defaultValue, placeholder, onChange, ...rest } = props + + const [selectedOption, setSelectedOption] = React.useState( + defaultValue?.value + ) + + const flatObject = options + .map((option) => { + if (Object.hasOwn(option, "options")) { + return option.options + } + + return option + }) + .flat() + + const handleOnChange: React.ChangeEventHandler = (e) => { + const selectedValue = e.target.value + const isPlaceholder = selectedValue === "" + + setSelectedOption(selectedValue) + + const selectedOptionData = flatObject.find( + (option) => option.value === selectedValue + ) + + if (!selectedOptionData && !isPlaceholder) return + + onChange(selectedOptionData ?? "") + } + + return ( + + {options.map((option, idx) => { + return Object.hasOwn(option, "options") ? ( + + {option.options.map(({ label, value }) => ( + + ))} + + ) : ( + + ) + })} + + ) +} + +export default Select diff --git a/src/components/SelectableCard.tsx b/src/components/SelectableCard.tsx deleted file mode 100644 index 3d5c50195d8..00000000000 --- a/src/components/SelectableCard.tsx +++ /dev/null @@ -1,70 +0,0 @@ -import React from "react" -import styled from "@emotion/styled" -import Emoji from "./OldEmoji" - -import Checkbox from "./Checkbox" - -const StyledCard = styled.div` - display: flex; - flex-direction: column; - justify-content: space-between; - background: ${(props) => props.theme.colors.searchBackground}; - border-radius: 4px; - border: 1px solid ${(props) => props.theme.colors.lightBorder}; - padding: 1.5rem; - cursor: pointer; -` - -const Description = styled.p` - opacity: 0.8; -` - -const TopContent = styled.div` - position: relative; -` -export interface IProps { - children?: React.ReactNode - emoji: string - title: string - description: string - className?: string - onSelect: (val: string) => void - value: string - isSelected?: boolean -} - -const Card: React.FC = ({ - emoji, - title, - description, - children, - className, - onSelect, - value, - isSelected = false, -}) => { - const handleSelect = () => { - onSelect(value) - } - - return ( - - - - -

{title}

- {description} - - {children} - - ) -} - -export default Card diff --git a/src/components/Staking/StakingCommunityCallout.tsx b/src/components/Staking/StakingCommunityCallout.tsx index 8311fa946dd..4ae5bc2cd59 100644 --- a/src/components/Staking/StakingCommunityCallout.tsx +++ b/src/components/Staking/StakingCommunityCallout.tsx @@ -1,8 +1,7 @@ import React from "react" import { useTranslation } from "gatsby-plugin-react-i18next" -import styled from "@emotion/styled" import { graphql, useStaticQuery } from "gatsby" -import { FlexProps } from "@chakra-ui/react" +import { Flex, FlexProps } from "@chakra-ui/react" import ButtonLink from "../ButtonLink" import CalloutBanner from "../CalloutBanner" @@ -11,20 +10,6 @@ import Translation from "../Translation" import { trackCustomEvent } from "../../utils/matomo" import { getImage } from "../../utils/image" -const ButtonContainer = styled.div` - display: flex; - gap: 1rem; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - flex-direction: column; - } -` - -const StyledButtonLink = styled(ButtonLink)` - @media (max-width: ${({ theme }) => theme.breakpoints.s}) { - width: 100%; - } -` - export interface IProps extends FlexProps { id?: string } @@ -54,8 +39,8 @@ const StakingCommunityCallout: React.FC = (props) => { titleKey={"page-staking-join-community"} descriptionKey={"page-staking-join-community-desc"} > - - + { trackCustomEvent({ eventCategory: `StakingCommunityCallout`, @@ -64,10 +49,11 @@ const StakingCommunityCallout: React.FC = (props) => { }) }} to="https://discord.io/ethstaker" + w={{ base: "full", md: "auto" }} > Discord - - + { trackCustomEvent({ eventCategory: `StakingCommunityCallout`, @@ -76,10 +62,11 @@ const StakingCommunityCallout: React.FC = (props) => { }) }} to="https://reddit.com/r/ethstaker" + w={{ base: "full", md: "auto" }} > Reddit - - + { trackCustomEvent({ eventCategory: `StakingCommunityCallout`, @@ -88,10 +75,11 @@ const StakingCommunityCallout: React.FC = (props) => { }) }} to="https://ethstaker.cc" + w={{ base: "full", md: "auto" }} > - - + + ) } diff --git a/src/components/Staking/StakingConsiderations/index.tsx b/src/components/Staking/StakingConsiderations/index.tsx index 7f671eae0e0..1e6aea103bb 100644 --- a/src/components/Staking/StakingConsiderations/index.tsx +++ b/src/components/Staking/StakingConsiderations/index.tsx @@ -1,12 +1,12 @@ import React from "react" import { Box, - chakra, Flex, Heading, List, ListItem, Text, + useToken, VStack, } from "@chakra-ui/react" @@ -23,12 +23,6 @@ import Translation from "../../Translation" import { trackCustomEvent } from "../../../utils/matomo" import { useStakingConsiderations } from "./use-staking-considerations" -const ChakraButtonDropdown = chakra(ButtonDropdown, { - baseStyle: { - hideFrom: "md", - }, -}) - const IndicatorGroup = ({ label, styleObj, @@ -72,6 +66,9 @@ export interface IProps { } const StakingConsiderations: React.FC = ({ page }) => { + // TODO: Replace with direct token implementation after UI migration is completed + const mdBp = useToken("breakpoints", "md") + const { StyledSvg, caution, @@ -79,7 +76,6 @@ const StakingConsiderations: React.FC = ({ page }) => { dropdownLinks, handleSelection, indicatorSvgStyle, - selectionSvgStyle, title, valid, warning, @@ -89,9 +85,9 @@ const StakingConsiderations: React.FC = ({ page }) => { return ( - + {/* TODO: Improve a11y */} - + {!!pageData && ( {/* TODO: Make mobile responsive */} @@ -138,7 +134,7 @@ const StakingConsiderations: React.FC = ({ page }) => { minH="410px" p={6} > - + { setActiveIndex(idx) } - const selectionSvgStyle = { width: 72, height: "auto" } const indicatorSvgStyle = { width: 20, height: "auto" } const StyledSvg = !!Svg - ? styled(Svg)` - path { - fill: ${({ theme }) => theme.colors.text}; - } - ` - : styled.div` - display: none; - ` + ? chakra(Svg, { + baseStyle: { + path: { + fill: "text", + }, + }, + }) + : chakra("div", { + baseStyle: { + display: "none", + }, + }) return { title, @@ -418,7 +421,6 @@ export const useStakingConsiderations = ({ page }: IProps) => { warning, dropdownLinks, handleSelection, - selectionSvgStyle, indicatorSvgStyle, StyledSvg, pageData, diff --git a/src/components/Staking/WithdrawalCredentials.tsx b/src/components/Staking/WithdrawalCredentials.tsx index 4be9507e734..ca3cb6449ec 100644 --- a/src/components/Staking/WithdrawalCredentials.tsx +++ b/src/components/Staking/WithdrawalCredentials.tsx @@ -1,11 +1,12 @@ // Import libraries import React, { FC, useState, useMemo, ChangeEvent } from "react" -import { Button, Flex, Input, Text } from "@chakra-ui/react" +import { Button, Flex, Text } from "@chakra-ui/react" import { useTranslation } from "gatsby-plugin-react-i18next" // Components import CopyToClipboard from "../CopyToClipboard" import Emoji from "../Emoji" import Translation from "../Translation" +import Input from "../Input" // Utilites import { trackCustomEvent } from "../../utils/matomo" @@ -139,15 +140,11 @@ const WithdrawalCredentials: FC = () => { = ({ { handleZenModeChange() diff --git a/src/components/icons/staking/OriginEtherGlyphIcon.tsx b/src/components/icons/staking/OriginEtherGlyphIcon.tsx deleted file mode 100644 index abaf4c469c7..00000000000 --- a/src/components/icons/staking/OriginEtherGlyphIcon.tsx +++ /dev/null @@ -1,81 +0,0 @@ -import React from "react" -import { createIcon } from "@chakra-ui/react" -import { commonIconDefaultProps } from "../utils" - -export const OriginEtherGlyphIcon = createIcon({ - displayName: "OriginEtherGlyphIcon", - viewBox: "0 0 33 33", - defaultProps: { - width: "33px", - height: "33px", - ...commonIconDefaultProps, - }, - path: [ - , - , - , - , - , - , - , - , - , - , - - - - - - - - - - , - ], -}) diff --git a/src/components/icons/staking/index.ts b/src/components/icons/staking/index.ts index 44cca847704..d11ce7f1fcc 100644 --- a/src/components/icons/staking/index.ts +++ b/src/components/icons/staking/index.ts @@ -18,7 +18,6 @@ export * from "./LidoGlyphIcon" export * from "./LiquidityTokenIcon" export * from "./MultiClientIcon" export * from "./OpenSourceStakingIcon" -export * from "./OriginEtherGlyphIcon" export * from "./PermissionlessIcon" export * from "./RocketPoolGlyphIcon" export * from "./RockXGlyphIcon" diff --git a/src/content/community/online/index.md b/src/content/community/online/index.md index c339c08f8fb..3c8d2b24c50 100644 --- a/src/content/community/online/index.md +++ b/src/content/community/online/index.md @@ -24,7 +24,7 @@ Hundreds of thousands of Ethereum enthusiasts gather in these online forums to s Ethereum Cat Herders - community oriented around offering project management support to Ethereum development Ethereum Hackers - Discord chat run by ETHGlobal: an online community for Ethereum hackers all over the world CryptoDevs - Ethereum development focused Discord community -EthStaker Discord - community oriented around offering project management support to Ethereum development +EthStaker Discord - community-run guidance, education, support, and resources for existing and potential stakers Ethereum.org website team - stop by and chat ethereum.org web development and design with the team and folks from the community Matos Discord - web3 creators community where builders, industrial figureheads, and Ethereum enthusiasts hang out. We're passionate about web3 development, design, and culture. Come build with us. Solidity Gitter - chat for solidity development (Gitter) diff --git a/src/content/contributing/design/adding-design-resources/index.md b/src/content/contributing/design/adding-design-resources/index.md new file mode 100644 index 00000000000..4666100ad8e --- /dev/null +++ b/src/content/contributing/design/adding-design-resources/index.md @@ -0,0 +1,67 @@ +--- +title: Adding design resources +description: Guidelines and requirements to ensure quality of design materials on ethereum.org +lang: en +--- + +Anybody can suggest new design materials to the [Design and UX in web3 page](/developers/docs/design-and-ux/). + +Be aware that the focus of this page is on providing user value to aspiring web3 designers. The design section is not there to advertise your services, products, or platforms. + +To ensure that we maintain a high standard of information and promote valuable insights, we have established a listing policy: + +## Research Studies and Dashboards {#Research-studies} + +1. Sound Methodology + +a. The methodology should clearly define how the data was collected. + +b. The number of participants involved in the research should be stated. + +c. The research methods employed should be described. + +2. Relevance to Web3 Designers and Common Design Use Cases + +a. The topic of the research should be relevant to web3 designers and address common design use cases. + +3. Focus on delivering insights + +a. The primary objective of the text should be sharing insights rather than promoting a specific project or company. + +## Articles {#Articles} + +1. Relevance to Web3 Designers/Researchers and Common Web3 Design Use Cases + +a. The topic of the article should be pertinent to web3 designers and researchers, focusing on common web3 design use cases. + +2. Basic Writing Quality + +a. The article should be free of grammar and spelling mistakes. + +b. Emphasis should be placed on delivering key insights and learnings. + +c. The writing should be concise and to the point. + +3. Goal of the Text + +a. The primary goal of the article should be sharing insights rather than promoting a particular project or company. + +## Communities / DAOs {#Communities-and-DAOs} + +1. Website must clearly indicate how to join the DAO/Community + +2. Clear Benefits of Membership + +a. The benefits of becoming a member should be prominently displayed. + +**Examples**: receiving feedback on work, accessing job opportunities or bounties, sharing design and research insights. + +3. Active and Vibrant Communication on Discord + +a. The Discord community should exhibit lively and engaged communication. + +b. Moderators should be actively involved in maintaining the community and facilitating discussions. + +c. The community should demonstrate a track record of valuable and productive conversations within the last two weeks. + +By adhering to these criteria, we aim to foster a thriving and knowledge-sharing environment within our community. We believe that this white listing policy will ensure that our users have access to reliable, relevant, and insightful resources. Thank you for your understanding and cooperation in maintaining the quality of content within our platform. diff --git a/src/content/contributing/design/index.md b/src/content/contributing/design/index.md index 4465a8cd141..7d5097b4fb1 100644 --- a/src/content/contributing/design/index.md +++ b/src/content/contributing/design/index.md @@ -58,7 +58,7 @@ Our design system makes designing ethereum.org fun and easy. If you are an exper ### Write design-related content on the website {#write-design-articles} -The Ethereum developer community is strong, but the design community is falling slightly behind. If you are a designer with web3 knowledge, please consider sharing your learnings with the larger community so that we can all grow and improve together; we have [a page on designing for Ethereum](/developers/docs/design-and-ux/) you can contribute to. +The Ethereum developer community is strong, but the design community is falling slightly behind. If you are a designer with web3 knowledge, please consider sharing your learnings with the larger community so that we can all grow and improve together; we have [a page on designing for Ethereum](/developers/docs/design-and-ux/) you can contribute to. You can also check our [listing policies](/contributing/design/adding-design-resources). 1. Ideate on design topics that should be covered on ethereum.org and would be beneficial for the designers in the space. 2. Go to our GitHub repository and [raise an issue](https://github.com/ethereum/ethereum-org-website/issues/new) proposing a topic (do not write the content yet). diff --git a/src/content/contributing/index.md b/src/content/contributing/index.md index 25c8bbf4f1c..740fc269500 100644 --- a/src/content/contributing/index.md +++ b/src/content/contributing/index.md @@ -46,6 +46,7 @@ The ethereum.org website, like Ethereum more broadly, is an open-source project. - [Suggest a project for our DeSci page](/contributing/adding-desci-projects/) _- Add a project built on Ethereum that contributes to decentralized science_ - [Quizzes](/contributing/quizzes/) _- Add, update, and delete quiz question banks for a relevant page_ +- [Suggest a design resource](/contributing/design/adding-design-resources/) _- Add, update, and delete helpful design resources_ _Any questions?_ 🤔 Reach out on our [Discord server](https://discord.gg/CetY6Y4) diff --git a/src/content/contributing/translation-program/content-buckets/index.md b/src/content/contributing/translation-program/content-buckets/index.md index 6598d74e5a5..df435715865 100644 --- a/src/content/contributing/translation-program/content-buckets/index.md +++ b/src/content/contributing/translation-program/content-buckets/index.md @@ -98,7 +98,6 @@ Below is a breakdown of the website pages each content bucket contains. - [Verkle trees](/roadmap/verkle-trees/) - [Statelessness, state expiry and history expiry](/roadmap/statelessness/) - ## 10) Community pages {#community-pages} - [Ethereum events](/community/events/) diff --git a/src/content/contributing/translation-program/resources/index.md b/src/content/contributing/translation-program/resources/index.md index 1ac313d4578..122e8c09c93 100644 --- a/src/content/contributing/translation-program/resources/index.md +++ b/src/content/contributing/translation-program/resources/index.md @@ -44,7 +44,7 @@ To keep up-to-date with the latest Translation Program progress, you can follow ## Office hours for translators {#office-hours} -We have office hours for translators on the second Wednesday of every month. These are held in the #office-hours voice channel on the [ethereum.org Discord](https://discord.gg/geKhWjtF), where you can also find the exact times and additional details. +We have office hours for translators on the second Wednesday of every month. These are held in the #office-hours voice channel on the [ethereum.org Discord](/discord/), where you can also find the exact times and additional details. Office hours allow our translators to ask questions about the translation process, provide feedback on the program, share their ideas, or just chat with the core ethereum.org team. Finally, we want to use these calls to communicate recent developments with the Translation Program and share key tips and instructions with our contributors. diff --git a/src/content/developers/docs/consensus-mechanisms/pos/block-proposal/index.md b/src/content/developers/docs/consensus-mechanisms/pos/block-proposal/index.md index d2f6d8cc249..5ad05733046 100644 --- a/src/content/developers/docs/consensus-mechanisms/pos/block-proposal/index.md +++ b/src/content/developers/docs/consensus-mechanisms/pos/block-proposal/index.md @@ -42,7 +42,7 @@ class BeaconBlockBody(Container): execution_payload: ExecutionPayload ``` -The `randao_reveal` field takes a verifiable random value that the block proposer creates by adding some of its own entropy to the accumulated RANDAO value from previous blocks. `eth1_data` is a vote for the block proposer's view of the deposit contract, including the root of the deposit Merkle trie and the total number of deposits that enable new deposits to be verified. `graffiti` is an optional field that can be used to add a message to the block. `proposer_slashings` and `attester_slashings` are fields that contain proof that certain validators have committed slashable offenses according to the proposer's view of the chain. `deposits` is a list of new validator deposits that the block proposer is aware of, and `voluntary_exits` is a list of validators that wish to exit that the block proposer has heard about on the consensus layer gossip network. The `sync_aggregate` is a vector showing which validators were previously assigned to a sync committee (a subset of validators that serve light client data) and participated in signing data. +The `randao_reveal` field takes a verifiable random value that the block proposer creates by signing the current epoch number. `eth1_data` is a vote for the block proposer's view of the deposit contract, including the root of the deposit Merkle trie and the total number of deposits that enable new deposits to be verified. `graffiti` is an optional field that can be used to add a message to the block. `proposer_slashings` and `attester_slashings` are fields that contain proof that certain validators have committed slashable offenses according to the proposer's view of the chain. `deposits` is a list of new validator deposits that the block proposer is aware of, and `voluntary_exits` is a list of validators that wish to exit that the block proposer has heard about on the consensus layer gossip network. The `sync_aggregate` is a vector showing which validators were previously assigned to a sync committee (a subset of validators that serve light client data) and participated in signing data. The `execution_payload` enables information about transactions to be passed between the execution and consensus clients. The `execution_payload` is a block of execution data that gets nested inside a beacon block. The fields inside the `execution_payload` reflect the block structure outlined in the Ethereum yellow paper, except that there are no ommers and `prev_randao` exists in place of `difficulty`. The execution client has access to a local pool of transactions that it has heard about on its own gossip network. These transactions are executed locally to generate an updated state trie known as a post-state. The transactions are included in the `execution_payload` as a list called `transactions` and the post-state is provided in the `state-root` field. diff --git a/src/content/developers/docs/data-and-analytics/block-explorers/index.md b/src/content/developers/docs/data-and-analytics/block-explorers/index.md index 4bf06d903d3..fb4d599cbab 100644 --- a/src/content/developers/docs/data-and-analytics/block-explorers/index.md +++ b/src/content/developers/docs/data-and-analytics/block-explorers/index.md @@ -21,7 +21,7 @@ You should understand the basic concepts of Ethereum so you can make sense of th - [Ethplorer](https://ethplorer.io/) -_Also available in Chinese, Spanish, French, Turkish, Russian, Korean and Vietnamese_ - [OKLink](https://www.oklink.com/eth) - [Otterscan](https://otterscan.io/) -- [Rantom](https://rantom.app/) +- [Rantom](https://rantom.app/) - [Sirato](https://www.web3labs.com/sirato) - [EthVM](https://www.ethvm.com/) diff --git a/src/content/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md b/src/content/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md index c6f261d310e..7b0760d7d99 100644 --- a/src/content/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md +++ b/src/content/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md @@ -233,6 +233,8 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [ {"jsonrpc":"2.0","id":1,"result":"0x000000000000000000000000000000000000000000000000000000000000162e"} ``` +Note: The `storageRoot` for an Ethereum account is empty by default if it's not a contract account. + ### Transactions Trie {#transaction-trie} There is a separate transactions trie for every block, again storing `(key, value)` pairs. A path here is: `rlp(transactionIndex)` which represents the key that corresponds to a value determined by: diff --git a/src/content/developers/docs/design-and-ux/index.md b/src/content/developers/docs/design-and-ux/index.md index 7ff4f6b323c..19179d25fc6 100644 --- a/src/content/developers/docs/design-and-ux/index.md +++ b/src/content/developers/docs/design-and-ux/index.md @@ -79,3 +79,6 @@ Get involved in professional community-driven organizations or join design group - [Finity, a design system for Web3 by Polygon](https://finity.polygon.technology/) (Figma) - [ENS Design system](https://thorin.ens.domains/) - [Mirror Design System](https://degen-xyz.vercel.app/) + +**Articles and projects listed on this page are not official endorsements**, and are provided for informational purposes only. +We add links to this page based on criteria in our [listing policy](/contributing/design/adding-design-resources). If you'd like us to add a project/article, edit this page on [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/src/content/developers/docs/design-and-ux/index.md). diff --git a/src/content/developers/docs/evm/opcodes/index.md b/src/content/developers/docs/evm/opcodes/index.md index 74bef0cb3c4..d3e51863ad7 100644 --- a/src/content/developers/docs/evm/opcodes/index.md +++ b/src/content/developers/docs/evm/opcodes/index.md @@ -87,7 +87,8 @@ For operations with dynamic gas costs, see [gas.md](https://github.com/wolflo/ev | 59 | MSIZE | 2 | `.` | `len(mem)` | | size of memory in current execution context, in bytes | | 5A | GAS | 2 | `.` | `gasRemaining` | | | 5B | JUMPDEST | 1 | | | mark valid jump destination | a valid jump destination for example a jump destination not inside the push data | -| 5C-5F | _invalid_ | +| 5C-5E | _invalid_ | +| 5F | PUSH0 | 2 | `.` | `uint8` | | push the constant value 0 onto stack | | 60 | PUSH1 | 3 | `.` | `uint8` | | push 1-byte value onto stack | | 61 | PUSH2 | 3 | `.` | `uint16` | | push 2-byte value onto stack | | 62 | PUSH3 | 3 | `.` | `uint24` | | push 3-byte value onto stack | diff --git a/src/content/developers/docs/gas/index.md b/src/content/developers/docs/gas/index.md index f3281e72141..9bf091e6dc3 100644 --- a/src/content/developers/docs/gas/index.md +++ b/src/content/developers/docs/gas/index.md @@ -69,7 +69,7 @@ The base fee is calculated by a formula that compares the size of the previous b | 7 | 30M | 12.5% | 180.2 gwei | | 8 | 30M | 12.5% | 202.7 gwei | -Relative to the pre-London gas auction market, this transaction-fee-mechanism change causes fee prediction to be more reliable. Following the table above - to create a transaction on block number 9, a wallet will let the user know with certainty that the **maximum base fee** to be added to the next block is `current base fee * 12.5%` or `202.7 gwei * 12.5% = 228.1 gwei`. +Relative to the pre-London gas auction market, this transaction-fee-mechanism change causes fee prediction to be more reliable. Following the table above - to create a transaction on block number 9, a wallet will let the user know with certainty that the **maximum base fee** to be added to the next block is `current base fee * 112.5%` or `202.7 gwei * 112.5% = 228.1 gwei`. It's also important to note it is unlikely we will see extended spikes of full blocks because of the speed at which the base fee increases proceeding a full block. diff --git a/src/content/developers/docs/nodes-and-clients/node-architecture/index.md b/src/content/developers/docs/nodes-and-clients/node-architecture/index.md index a2a8fedeca1..54bbcac421d 100644 --- a/src/content/developers/docs/nodes-and-clients/node-architecture/index.md +++ b/src/content/developers/docs/nodes-and-clients/node-architecture/index.md @@ -45,7 +45,7 @@ Node operators can add a validator to their consensus clients by depositing 32 E | Execution Client | Consensus Client | Validator | | -------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------- | -| Gossips transactions over its p2p network | Gossips blocks and attestations overs its p2p network | Proposes blocks | +| Gossips transactions over its p2p network | Gossips blocks and attestations over its p2p network | Proposes blocks | | Executes/re-executes transactions | Runs the fork choice algorithm | Accrues rewards/penalties | | Verifies incoming state changes | Keeps track of the head of the chain | Makes attestations | | Manages state and receipts tries | Manages the Beacon state (contains consensus and execution info) | Requires 32 ETH to be staked | diff --git a/src/content/developers/docs/oracles/index.md b/src/content/developers/docs/oracles/index.md index 071916a83bb..2fe5a2d769f 100644 --- a/src/content/developers/docs/oracles/index.md +++ b/src/content/developers/docs/oracles/index.md @@ -364,7 +364,7 @@ The usual approach is to use pseudorandom cryptographic functions, such as `bloc It is possible to generate the random value off-chain and send it on-chain, but doing so imposes high trust requirements on users. They must believe the value was truly generated via unpredictable mechanisms and wasn’t altered in transit. -Oracles designed for off-chain computation solve this problem by securely generating random outcomes off-chain that they broadcast on-chain along with cryptographic proofs attesting to the unpredictability of the process. An example is [Chainlink VRF](https://docs.chain.link/docs/chainlink-vrf/) (Verifiable Random Function), which is a provably fair and tamper-proof random number generator (RNG) useful for building reliable smart contracts for applications that rely on unpredictable outcomes. +Oracles designed for off-chain computation solve this problem by securely generating random outcomes off-chain that they broadcast on-chain along with cryptographic proofs attesting to the unpredictability of the process. An example is [Chainlink VRF](https://docs.chain.link/docs/chainlink-vrf/) (Verifiable Random Function), which is a provably fair and tamper-proof random number generator (RNG) useful for building reliable smart contracts for applications that rely on unpredictable outcomes. Another example is [API3 QRNG](https://docs.api3.org/explore/qrng/) that serves Quantum random number generation (QRNG) is a public method of Web3 RNG based on quantum phenomena, served with the courtesy of the Australian National University (ANU). ### Getting outcomes for events {#getting-outcomes-for-events} @@ -402,6 +402,8 @@ There are multiple oracle applications you can integrate into your Ethereum dapp **[Pyth Network](https://pyth.network/)** - _The Pyth network is a first-party financial oracle network designed to publish continuous real-world data on-chain in a tamper-resistant, decentralized, and self-sustainable environment._ +**[API3 DAO](https://www.api3.org/)** - _API3 DAO is delivering first-party oracle solutions that deliver greater source transparency, security and scalability in a decentralized solution for smart contracts_ + ## Further reading {#further-reading} **Articles** @@ -417,6 +419,7 @@ There are multiple oracle applications you can integrate into your Ethereum dapp **Videos** - [Oracles and the Expansion of Blockchain Utility](https://youtu.be/BVUZpWa8vpw) — _Real Vision Finance_ +- [The differences between first party and third party oracles](https://blockchainoraclesummit.io/first-party-vs-third-party-oracles/) - _Blockchain Oracle Summit_ **Tutorials** diff --git a/src/content/developers/docs/programming-languages/javascript/index.md b/src/content/developers/docs/programming-languages/javascript/index.md index b7f0de09f17..5813464e560 100644 --- a/src/content/developers/docs/programming-languages/javascript/index.md +++ b/src/content/developers/docs/programming-languages/javascript/index.md @@ -20,6 +20,7 @@ You can use these libraries to interact with smart contracts on Ethereum so it's - [Web3.js](https://web3js.readthedocs.io/) - [Ethers.js](https://docs.ethers.io/) _– includes Ethereum wallet implementation and utilities in JavaScript and TypeScript._ +- [viem](https://viem.sh) – a TypeScript Interface for Ethereum that provides low-level stateless primitives for interacting with Ethereum. ### Smart contracts {#smart-contracts} @@ -50,10 +51,12 @@ If you prefer to read code, this JavaScript could be a great alternative to read ### Nodes and clients {#nodes-and-clients} -There's an Ethereumjs client in development. This will let you dig into how Ethereum clients work in a language you understand. +An Ethereumjs client is in active development that lets you dig into how Ethereum clients work in a language you understand; JavaScript! + +It used to be housed in a standalone [`repository`](https://github.com/ethereumjs/ethereumjs-client), however, was later merged into the EthereumVM monorepo as a package. **Check out the client** -[`ethereumjs-client`](https://github.com/ethereumjs/ethereumjs-client) +[`ethereumjs-client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client) ## Other projects {#other-projects} diff --git a/src/content/developers/docs/smart-contracts/security/index.md b/src/content/developers/docs/smart-contracts/security/index.md index c9cc64b80da..1442d761c9c 100644 --- a/src/content/developers/docs/smart-contracts/security/index.md +++ b/src/content/developers/docs/smart-contracts/security/index.md @@ -504,6 +504,8 @@ If you plan on querying an on-chain oracle for asset prices, consider using one - **[HashEx](https://hashex.org/)** - _HashEx focuses on blockchain and smart contract auditing to ensure the security of cryptocurrencies, providing services such as smart contract development, penetration testing, blockchain consulting._ +- **[Code4rena](https://code4rena.com/)** - _Competitive audit platform that incentivizes smart contract security experts to find vulnerabilities and help make web3 more secure._ + ### Bug bounty platforms {#bug-bounty-platforms} - **[Immunefi](https://immunefi.com/)** - _Bug bounty platform for smart contracts and DeFi projects, where security researchers review code, disclose vulnerabilities, get paid, and make crypto safer._ @@ -512,8 +514,6 @@ If you plan on querying an on-chain oracle for asset prices, consider using one - **[HackenProof](https://hackenproof.com/)** - _Expert bug bounty platform for crypto projects (DeFi, Smart Contracts, Wallets, CEX and more), where security professionals provide triage services and researchers get paid for relevant, verified bug reports._ -- **[Code4rena](https://code4rena.com/)** - _Competitive audit platform that incentivizes smart contract security experts to find vulnerabilities and help make web3 more secure._ - ### Publications of known smart contract vulnerabilities and exploits {#common-smart-contract-vulnerabilities-and-exploits} - **[ConsenSys: Smart Contract Known Attacks](https://consensys.github.io/smart-contract-best-practices/attacks/)** - _Beginner-friendly explanation of the most significant contract vulnerabilities, with sample code for most cases._ diff --git a/src/content/developers/docs/standards/tokens/erc-721/index.md b/src/content/developers/docs/standards/tokens/erc-721/index.md index b2e0e6dee7a..deaf71ea562 100644 --- a/src/content/developers/docs/standards/tokens/erc-721/index.md +++ b/src/content/developers/docs/standards/tokens/erc-721/index.md @@ -141,7 +141,7 @@ ck_extra_abi = [ } ] -ck_contract = w3.eth.contract(address=w3.toChecksumAddress(ck_token_addr), abi=simplified_abi+ck_extra_abi) +ck_contract = w3.eth.contract(address=w3.to_checksum_address(ck_token_addr), abi=simplified_abi+ck_extra_abi) name = ck_contract.functions.name().call() symbol = ck_contract.functions.symbol().call() kitties_auctions = ck_contract.functions.balanceOf(acc_address).call() @@ -162,25 +162,25 @@ tx_event_abi = { } # We need the event's signature to filter the logs -event_signature = w3.sha3(text="Transfer(address,address,uint256)").hex() +event_signature = w3.keccak(text="Transfer(address,address,uint256)").hex() -logs = w3.eth.getLogs({ - "fromBlock": w3.eth.blockNumber - 120, - "address": w3.toChecksumAddress(ck_token_addr), +logs = w3.eth.get_logs({ + "fromBlock": w3.eth.block_number - 120, + "address": w3.to_checksum_address(ck_token_addr), "topics": [event_signature] }) # Notes: -# - 120 blocks is the max range for CloudFlare Provider +# - Increase the number of blocks up from 120 if no Transfer event is returned. # - If you didn't find any Transfer event you can also try to get a tokenId at: # https://etherscan.io/address/0x06012c8cf97BEaD5deAe237070F9587f8E7A266d#events # Click to expand the event's logs and copy its "tokenId" argument - recent_tx = [get_event_data(w3.codec, tx_event_abi, log)["args"] for log in logs] -kitty_id = recent_tx[0]['tokenId'] # Paste the "tokenId" here from the link above -is_pregnant = ck_contract.functions.isPregnant(kitty_id).call() -print(f"{name} [{symbol}] NFTs {kitty_id} is pregnant: {is_pregnant}") +if recent_tx: + kitty_id = recent_tx[0]['tokenId'] # Paste the "tokenId" here from the link above + is_pregnant = ck_contract.functions.isPregnant(kitty_id).call() + print(f"{name} [{symbol}] NFTs {kitty_id} is pregnant: {is_pregnant}") ``` CryptoKitties Contract has some interesting Events other than the Standard ones. @@ -214,15 +214,15 @@ ck_extra_events_abi = [ # We need the event's signature to filter the logs ck_event_signatures = [ - w3.sha3(text="Pregnant(address,uint256,uint256,uint256)").hex(), - w3.sha3(text="Birth(address,uint256,uint256,uint256,uint256)").hex(), + w3.keccak(text="Pregnant(address,uint256,uint256,uint256)").hex(), + w3.keccak(text="Birth(address,uint256,uint256,uint256,uint256)").hex(), ] # Here is a Pregnant Event: # - https://etherscan.io/tx/0xc97eb514a41004acc447ac9d0d6a27ea6da305ac8b877dff37e49db42e1f8cef#eventlog -pregnant_logs = w3.eth.getLogs({ - "fromBlock": w3.eth.blockNumber - 120, - "address": w3.toChecksumAddress(ck_token_addr), +pregnant_logs = w3.eth.get_logs({ + "fromBlock": w3.eth.block_number - 120, + "address": w3.to_checksum_address(ck_token_addr), "topics": [ck_event_signatures[0]] }) @@ -230,9 +230,9 @@ recent_pregnants = [get_event_data(w3.codec, ck_extra_events_abi[0], log)["args" # Here is a Birth Event: # - https://etherscan.io/tx/0x3978028e08a25bb4c44f7877eb3573b9644309c044bf087e335397f16356340a -birth_logs = w3.eth.getLogs({ - "fromBlock": w3.eth.blockNumber - 120, - "address": w3.toChecksumAddress(ck_token_addr), +birth_logs = w3.eth.get_logs({ + "fromBlock": w3.eth.block_number - 120, + "address": w3.to_checksum_address(ck_token_addr), "topics": [ck_event_signatures[1]] }) diff --git a/src/content/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md b/src/content/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md index 28f85ac8034..eb77702e96c 100644 --- a/src/content/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md +++ b/src/content/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md @@ -89,7 +89,7 @@ cd sendtx-example Run the following command in your project directory to install [Alchemy Web3](https://docs.alchemy.com/reference/api-overview): -Note, if you'd like to use the ethers.js library, [follow the instructions here](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum). +Note, if you'd like to use the ethers.js library, [follow the instructions here](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum). ``` npm install @alch/alchemy-web3 diff --git a/src/content/guides/how-to-id-scam-tokens/etherscan-scam.png b/src/content/guides/how-to-id-scam-tokens/etherscan-scam.png new file mode 100644 index 00000000000..5a51583f747 Binary files /dev/null and b/src/content/guides/how-to-id-scam-tokens/etherscan-scam.png differ diff --git a/src/content/guides/how-to-id-scam-tokens/index.md b/src/content/guides/how-to-id-scam-tokens/index.md new file mode 100644 index 00000000000..751ea0714b4 --- /dev/null +++ b/src/content/guides/how-to-id-scam-tokens/index.md @@ -0,0 +1,101 @@ +--- +title: How to identify scam tokens +description: Understanding scam tokens, how they make themselves look legitimate, and how to avoid them. +lang: en +--- + +# How to identify scam tokens {#identify-scam-tokens} + +One of the most common uses for Ethereum is for a group to create a tradable token, in a sense their own currency. These tokens typically follow a standard, [ERC-20](/developers/docs/standards/tokens/erc-20/). However, anywhere there are legitimate use cases that bring value, there are also criminals who try to steal that value for themselves. + +There are two ways in which they are likely to deceive you: + +- **Selling you a scam token**, which may look like the legitimate token you want to purchase, but are issued by the scammers and worth nothing. +- **Tricking you into signing bad transactions**, usually by directing you into their own user interface. They mignt try to get you into giving their contracts an allowance on your ERC-20 tokens, exposing sensitive information that gives them access to your assets, etc.. These user interfaces might be near-perfect clones of honest sites, but with hidden tricks. + +To illustrate what scam tokens are, and how to identify them, we are going to look at an example of one: [`wARB`](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82). This token attempts to look like the legitimate [`ARB`](https://etherscan.io/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1) token. + + + +Arbitrum is an organization that develops and manages optimistic rollups. Initially Arbitrum was organized as a for-profit company, but then took steps to decentralize. As part of that process, they issued a tradeable governance token. + + + + + +There is a convention in Ethereum that when an asset is not ERC-20 compliant we create a "wrapped" version of it with the name starting with "w". So, for example, we have wBTC for bitcoin and wETH for ether. + +It does not make sense to create a wrapped version of an ERC-20 token that is already on Ethereum, but scammers rely on the appearance of legitimacy rather than the underlying reality. + + + + +## How do scam tokens work? {#how-do-scam-tokens-work} + +The whole point of Ethereum is decentralization. This means that there is no central authority that can confiscate your assets or prevent you from deploying a smart contract. But it also means that scammers can deploy any smart contract they wish. + + + +Smart contracts are the programs that run on top of the Ethereum blockchain. Every ERC-20 token, for example, is implemented as a smart contract. + + + +Specifically, Arbitrum deployed a contract that uses the symbol `ARB`. But that doesn't stop other people from also deploying a contract that uses the exact same symbol, or a similar one. Whoever writes the contract gets to set what the contract will do. + +## Appearing legitimate {#appearing-legitimate} + +There are several tricks that scam token creators do to appear legitimate. + +- **Legitimate name and symbol**. As mentioned before, ERC-20 contracts can have the same symbol and name as other ERC-20 contracts. You cannot count on those fields for security. + +- **Legitimate owners**. Scam tokens often airdrop significant balances to addresses that can be expected to be legitimate holders of the real token. + + For example, lets look at `wARB` again. [About 16% of the tokens](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82?a=0x1c8db745abe3c8162119b9ef2c13864cd1fdd72f) are held by an address whose public tag is [Arbitrum Foundation: Deployer](https://etherscan.io/address/0x1c8db745abe3c8162119b9ef2c13864cd1fdd72f). This is *not* a fake address, it really is the address that [deployed the real ARB contract on Ethereum mainnet](https://etherscan.io/tx/0x242b50ab4fe9896cb0439cfe6e2321d23feede7eeceb31aa2dbb46fc06ed2670). + + Because the ERC-20 balance of an address is part of the ERC-20 contract's storage, it can be specified by the contract to be whatever the contract developer wishes. It is also possible for a contract to forbid transfers so the legitimate users won't be able to get rid of those scam tokens. + +- **Legitimate transfers**. *Legitimate owners wouldn't pay to transfer a scam token to others, so if there are transfers it must be legitimate, right?* **Wrong**. `Transfer` events are produced by the ERC-20 contract. A scammer can easily write the contract in such a way it will produce those actions. + + +## Scammy websites {#websites} + +Scammers can also produce very convincing websites, sometimes even precise clones of authentic sites with identical UIs, but with subtle tricks. Examples might be external links that seem legitimate actually sending the user to an external scam site, or incorrect instructions that guide the user to exposing their keys or sending funds to an attacker's address. + +The best practise for avoiding this is to carefully check the URL for the sites you visit, and save addresses for known authentic sites in your bookmarks. Then, you can access the real site through your bookmarks without accidentally making spelling errors or relying on external links. + + +## How can you protect yourself? {#protect-yourself} + +1. **Check the contract address**. Legitimate tokens come from legitimate organizations, and you can see the contract addresses on the organization's web site. For example, [for `ARB` you can see the legitimate addresses here](https://docs.arbitrum.foundation/deployment-addresses#token). + +2. **Real tokens have liquidity**. Another option is to look at liquidity pool size on [Uniswap](https://uniswap.org/), one of the most common token swapping protocols. This protocol works using liquidity pools, into which investors deposit their tokens in hope of a return from trading fees. + +Scam tokens typically have tiny liquidity pools, if any, because the scammers don't want to risk real assets. For example, the `ARB`/`ETH` Uniswap pool holds about a million dollars ([see here for the up to date value](https://info.uniswap.org/#/pools/0x755e5a186f0469583bd2e80d1216e02ab88ec6ca)) and buying or selling a small amount is not going to change the price: + + ![Buying a legitimate token](./uniswap-real.png) + + But when you try to buy the scam token `wARB`, even a tiny purchase would change the price by over 90%: + + ![Buying a scam token](./uniswap-scam.png) + + This is another piece of evidence that shows us `wARB` is not likely to be a legitimate token. + +3. **Look in Etherscan**. A lot of scam tokens have already been identified and reported by the community. Such tokens are [marked in Etherscan](https://info.etherscan.com/etherscan-token-reputation/). While Etherscan is not authoritative source of truth (it is the nature of decentralized networks that there can't be an authoritative source for legitimacy), tokens that are identified by Etherscan as scams are likely to be scams. + + ![Scam token in Etherscan](./etherscan-scam.png) + + +## Conclusion {#conclusion} + +As long as there is value in the world, there are going to be scammers who attempt to steal it for themselves, and in a decentralized world there is nobody to protect you except for yourself. Hopefully, you remember these points to help tell the legitimate tokens from the scams: + +- Scam tokens impersonate legitimate tokens, they can use the same name, symbol, etc. +- Scam tokens *cannot* use the same contract address. +- The best source for the address of the legitimate token is the organization whose token it is. +- Failing that, you can use popular, trusted applications such as [Uniswap](https://app.uniswap.org/#/swap) and [Etherscan](https://etherscan.io/). diff --git a/src/content/guides/how-to-id-scam-tokens/uniswap-real.png b/src/content/guides/how-to-id-scam-tokens/uniswap-real.png new file mode 100644 index 00000000000..68304d73056 Binary files /dev/null and b/src/content/guides/how-to-id-scam-tokens/uniswap-real.png differ diff --git a/src/content/guides/how-to-id-scam-tokens/uniswap-scam.png b/src/content/guides/how-to-id-scam-tokens/uniswap-scam.png new file mode 100644 index 00000000000..d768924e127 Binary files /dev/null and b/src/content/guides/how-to-id-scam-tokens/uniswap-scam.png differ diff --git a/src/content/guides/index.md b/src/content/guides/index.md index 991bff3e9dc..0f1bbdd6e12 100644 --- a/src/content/guides/index.md +++ b/src/content/guides/index.md @@ -18,6 +18,8 @@ Do you want to start your Ethereum journey? Ethereum is not a corporation with a 1. [How to revoke smart contract access to your crypto funds](/guides/how-to-revoke-token-access/) - If you suddenly see a transaction in your wallet that you did not initiate, this guide will teach you how to prevent that from happening again. +2. [How to identify scam tokens](/guides/how-to-id-scam-tokens/) - What are scam tokens, how do they make themselves look legitimate, and how to identify them to protect yourself and avoid being scammed. + ## Using Ethereum 1. [How to bridge tokens to layer 2](/guides/how-to-use-a-bridge/) - Are Ethereum transactions too costly? Consider moving to Ethereum scaling solutions called layer 2s. diff --git a/src/content/history/index.md b/src/content/history/index.md index ab1ac98ddd5..2f45204872a 100644 --- a/src/content/history/index.md +++ b/src/content/history/index.md @@ -422,9 +422,9 @@ The Tangerine Whistle fork was the first response to the denial of service (DoS) #### Summary {#dao-fork-summary} -The DAO fork was in response to the [2016 DAO attack](https://www.coindesk.com/markets/2016/06/25/understanding-the-dao-attack/) where an insecure [DAO](/glossary/#dao) contract was drained of over 3.6 million ETH in a hack. The fork moved the funds from the faulty contract to a [new contract](https://etherscan.io/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754) with a single function: withdraw. Anyone who lost funds could withdraw 1 ETH for every 100 DAO tokens in their wallets. +The DAO fork was in response to the [2016 DAO attack](https://www.coindesk.com/learn/understanding-the-dao-attack/) where an insecure [DAO](/glossary/#dao) contract was drained of over 3.6 million ETH in a hack. The fork moved the funds from the faulty contract to a [new contract](https://etherscan.io/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754) with a single function: withdraw. Anyone who lost funds could withdraw 1 ETH for every 100 DAO tokens in their wallets. -This course of action was voted on by the Ethereum community. Any ETH holder was able to vote via a transaction on [a voting platform](http://v1.carbonvote.com/). The decision to fork reached over 85% of the votes. +This course of action was voted on by the Ethereum community. Any ETH holder was able to vote via a transaction on [a voting platform](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). The decision to fork reached over 85% of the votes. Some miners refused to fork because the DAO incident wasn't a defect in the protocol. They went on to form [Ethereum Classic](https://ethereumclassic.org/). diff --git a/src/content/roadmap/danksharding/index.md b/src/content/roadmap/danksharding/index.md index 746273e024b..8636bf7f668 100644 --- a/src/content/roadmap/danksharding/index.md +++ b/src/content/roadmap/danksharding/index.md @@ -31,7 +31,7 @@ Rollups post commitments to their transaction data on-chain and also make the ac ### How is blob data verified? {#how-are-blobs-verified} -Rollups post the transactions they execute in data blobs. They also post a "commitment" to the data. They do this by fitting a polynomial function to the data. This function can then be evaluated at various points. For example, if we define an extremely simply function `f(x) = 2x-1` then we can evaluate this function for `x = 1`, `x = 2`, `x = 3` giving the results `1, 3, 5`. A prover applies the same function to the data and evaluates it at the same points. If the original data is changed, the function will not be identical, and therefore neither are the values evaluated at each point. In reality, the commitment and proof are more complicated because they are wrapped in cryptographic functions. +Rollups post the transactions they execute in data blobs. They also post a "commitment" to the data. They do this by fitting a polynomial function to the data. This function can then be evaluated at various points. For example, if we define an extremely simple function `f(x) = 2x-1` then we can evaluate this function for `x = 1`, `x = 2`, `x = 3` giving the results `1, 3, 5`. A prover applies the same function to the data and evaluates it at the same points. If the original data is changed, the function will not be identical, and therefore neither are the values evaluated at each point. In reality, the commitment and proof are more complicated because they are wrapped in cryptographic functions. ### What is KZG? {#what-is-kzg} diff --git a/src/content/security/index.md b/src/content/security/index.md index 52ec0b46e03..1ba2e896b1c 100644 --- a/src/content/security/index.md +++ b/src/content/security/index.md @@ -285,6 +285,7 @@ Airdrop scams involve a scam project airdropping an asset (NFT, token) into your ### Scam education {#reading-scam-education} +- [Guide: How to identify scam tokens](/guides/how-to-id-scam-tokens/) - [Staying Safe: Common Scams](https://support.mycrypto.com/staying-safe/common-scams) - _MyCrypto_ - [Avoiding Scams](https://bitcoin.org/en/scams) - _Bitcoin.org_ - [Twitter thread on common crypto phishing emails and messages](https://twitter.com/tayvano_/status/1516225457640787969) - _Taylor Monahan_ diff --git a/src/content/staking/pools/index.md b/src/content/staking/pools/index.md index a77d59203fd..9164059a47a 100644 --- a/src/content/staking/pools/index.md +++ b/src/content/staking/pools/index.md @@ -49,12 +49,12 @@ Attribute indicators are used below to signal notable strengths or weaknesses a There are a variety of options available to help you with your setup. Use the above indicators to help guide you through the tools below. - -Please note the importance of choosing a service that takes client diversity seriously, as it improves the security of the network, and limits your risk. Services that have evidence of limiting majority client use are indicated with "execution client diversity" and "consensus client diversity." - + +Please note the importance of choosing a service that takes [client diversity](/developers/docs/nodes-and-clients/client-diversity/) seriously, as it improves the security of the network, and limits your risk. Services that have evidence of limiting majority client use are indicated with "execution client diversity" and "consensus client diversity." + Have a suggestion for a staking tool we missed? Check out our [product listing policy](/contributing/adding-staking-products/) to see if it would be a good fit, and to submit it for review. ## Frequently asked questions {#faq} diff --git a/src/content/staking/saas/index.md b/src/content/staking/saas/index.md index 55f57ebf3e3..fb08c07b8c5 100644 --- a/src/content/staking/saas/index.md +++ b/src/content/staking/saas/index.md @@ -41,14 +41,14 @@ Attribute indicators are used below to signal notable strengths or weaknesses a Below are some available SaaS provider. Use the above indicators to help guide you through these services - -Please note the importance of supporting client diversity as it improves the security of the network, and limits your risk. Services that have evidence of limiting majority client use are indicated with "execution client diversity" and "consensus client diversity." - + #### SaaS providers +Please note the importance of supporting [client diversity](/developers/docs/nodes-and-clients/client-diversity/) as it improves the security of the network, and limits your risk. Services that have evidence of limiting majority client use are indicated with "execution client diversity" and "consensus client diversity." + #### Key Generators diff --git a/src/content/staking/solo/index.md b/src/content/staking/solo/index.md index b6712759fdd..ede2e0f249c 100644 --- a/src/content/staking/solo/index.md +++ b/src/content/staking/solo/index.md @@ -103,14 +103,14 @@ Attribute indicators are used below to signal notable strengths or weaknesses a There are a variety of options available to help you with your setup. Use the above indicators to help guide you through the tools below. - -Please note the importance of choosing a minority client as it improves the security of the network, and limits your risk. Tools that allow you to setup minority client are denoted as "multi-client." - + #### Node tools +Please note the importance of choosing a [minority client](/developers/docs/nodes-and-clients/client-diversity/) as it improves the security of the network, and limits your risk. Tools that allow you to setup minority client are denoted as "multi-client." + #### Key Generators These tools can be used as an alternative to the [Staking Deposit CLI](https://github.com/ethereum/staking-deposit-cli/) to help with key generation. diff --git a/src/content/translations/ar/decentralized-identity/index.md b/src/content/translations/ar/decentralized-identity/index.md new file mode 100644 index 00000000000..af743ba8b19 --- /dev/null +++ b/src/content/translations/ar/decentralized-identity/index.md @@ -0,0 +1,185 @@ +--- +title: الهوية اللامركزية +description: ما هي الهُوِيَّة اللامركزية، ولماذا هي مهمة؟ +lang: ar +template: use-cases +emoji: ":id:" +sidebarDepth: 2 +image: ../../../../assets/eth-gif-cat.png +summaryPoint1: جعلت أنظمة الهُوِيَّة التقليدية من إصدار المعرفات الخاصة بك، وصيانتها، والتحكم فيها، عملية مركزية. +summaryPoint2: حيث تغني الهُوِيَّة اللامركزية عن الاعتماد على أطراف ثالثة مركزية. +summaryPoint3: بفضل العملات الرقمية، أصبح لدى المستخدمين الآن الأدوات اللازمة لإصدار معرفات الهوية والمصادقات الخاصة بهم، والاحتفاظ بها، والتحكم فيها مرة أخرى. +--- + +تعزز الهُوِيَّة بشكل افتراضي جميع جوانب حياتك اليومية. إن استخدام الخدمات على الإنترنت، وفتح حساب بنكي، والتصويت في الانتخابات، وشراء الممتلكات، وتأمين وظيفة، كل هذه الأمور تتطلب إثبات هويتك. + +ومع ذلك، فإن نظم إدارة الهُوِيَّة التقليدية تعتمد منذ وقت طويل على وسطاء مركزيين يقومون بإصدار معرفات هويتك و [ومصادقاتك](#what-are-attestations)، والاحتفاظ بها، والتحكم فيها. مما يعني أنه لا يمكنك التحكم في المعلومات المتصلة بهويتك، أو تحديد مَن لديه حق الوصول إلى معلومات تحديد الهوية الشخصية (PII)، وصلاحيات وصول هذه الأطراف. + +لحل هذه المشاكل، لدينا أنظمة هُوِيَّة لامركزية مبنية على سلاسل الكتل العامة مثل إثيريوم. تتيح الهُوِيَّة اللامركزية للأفراد إدارة المعلومات المتصلة بهوياتهم. مع حلول الهوية اللامركزية، _تستطيع_ إنشاء معرفات، والمطالبة بمصادقاتك والاحتفاظ بها دون الاعتماد على السلطات المركزية، مثل مقدمي الخدمات أو الحكومات. + +## ما هي الهوية؟ {#what-is-identity} + +الهوية تعني إحساس الفرد بنفسه، وهو ما تحدده خصائص فريدة. كما تشير الهُوِيَّة إلى كيان _ الفرد_، أي كائن بشري متميز. كما قد تشير الهُوِيَّة إلى كيانات أخرى غير بشرية، مثل منظمة أو سلطة. + +## ما هي المعرّفات؟ {#what-are-identifiers} + +المعرف هو معلومة تعمل كمؤشر على هُوِيَّة أو هويات محددة. تشمل المعرّفات الشائعة ما يلي: + +- الاسم +- رقم الضمان الاجتماعي/رقم معرف الضريبة +- رقم الهاتف الجوال +- تاريخ ومكان الميلاد +- بيانات اعتماد الهوية الرقمية، مثل عناوين البريد الإلكتروني، أسماء المستخدمين، الصور الرمزية + +وهذه الأمثلة التقليدية لمعرفات الهوية يتم إصدارها، والاحتفاظ بها، والتحكم فيها بواسطة كيانات مركزية. تحتاج إلى إذن من حكومتك لتغيير اسمك، أو من منصة التواصل الاجتماعي لتغيير معرفك. + +## ما هي المصادقات؟ {#what-are-attestations} + +المصادقة هي مطالبة مقدمة من كيان بشأن كيان آخر. إذا كنت تعيش في الولايات المتحدة، فرخصة القيادة التي أصدرتها لك إدارة المركبات (كيان ما)، هي مصادقة لك (كيان آخر) بأنه من المسموح لك بشكل قانوني أن تقود سيارة. + +وتختلف المصادقات عن المعرفات. المصادقة _تحتوي على_ معرفات تشير إلى هُوِيَّة معينة، وتمثل مطالبة بسمة متعلقة بهذه الهُوِيَّة. لذلك، فإن رخصة القيادة تتضمن معرفات (الاسم، تاريخ الميلاد، العنوان) ولكنها أيضا مصادقة على حقك القانوني في القيادة. + +### ما هي المعرّفات اللامركزية؟ {#what-are-decentralized-identifiers} + +تعتمد المعرفات التقليدية مثل اسمك القانوني أو عنوان بريدك الإلكتروني على أطراف ثالثة - الحكومات ومقدمي خدمات البريد الإلكتروني. أما المعرّفات اللامركزية (DID) فهي مختلفة - فلا يصدرها أو يديرها أو يتحكم فيها أي كيان مركزي. + +ويقوم الأفراد بإصدار معرفات الهوية اللامركزية، والاحتفاظ بها، والتحكم فيها. [حساب إثيريوم](/developers/docs/accounts/) هو مثال على معرف لامركزي. يمكنك إنشاء العدد الذي تريده من الحسابات دون إذن من أي شخص ودون الحاجة لتخزينها في سجل مركزي. + +يتم تخزين معرّفات الهوية اللامركزية على دفاتر الأستاذ الموزعة (سلاسل الكتل) أو شبكات الأقران. هذا يجعل المعرفات اللامركزية (DID) [فريدة عالمياً، وقابلة للحل مع توافر عالي، وقابل للتحقق من التشفير](https://w3c-ccg.github.io/did-primer/). ويمكن ربط معرف الهُوِيَّة اللامركزية بمختلف الكيانات، بما في ذلك الأشخاص، أو المنظمات، أو المؤسسات الحكومية. + +## ما الذي يجعل معرّفات الهوية اللامركزية ممكنة؟ {#what-makes-decentralized-identifiers-possible} + +### 1. البنية التحتية للمفتاح العام (PKI) {#public-key-infrastructure} + +البنية التحتية للمفتاح العام (PKI) هي تدبير لأمن المعلومات يولد [مفتاح عام](/glossary/#public-key) و [مفتاح خاص](/glossary/#private-key) لكيان ما. يستخدم تشفير المفتاح العام في شبكات سلسلة الكتل للتحقق من هُوِيَّة المستخدم وإثبات ملكية الأصول الرقمية. + +بعض معرّفات الهوية اللامركزية، مثل حساب إثيريوم، يوفر مفاتيح عامة وخاصة. يعرف المفتاح العام المتحكم في الحساب، بينما المفاتيح الخاصة يمكنها توقيع وفك تشفير الرسائل لهذا الحساب. يوفر معرف المفتاح العام الإثباتات اللازمة لتوثيق الكيانات ومنع انتحال الشخصية أو استخدام هويات مزيفة، باستخدام [توقيعات التشفير](https://andersbrownworth.com/blockchain/public-private-keys/) للتحقق من جميع المطالبات. + +### 2. مخازن البيانات اللامركزية {#decentralized-datastores} + +تعمل سلسلة الكتل كسجل بيانات يمكن التحقق منه: مستودع مفتوح وموثوق به ولا مركزي للمعلومات. إن وجود سلسلة الكتل العامة يزيل الحاجة إلى تخزين المعرفات في سجلات مركزية. + +وفي حال احتاج أي شخص إلى تأكيد صلاحية معرِّف لامركزي، فيمكنه البحث عن المفتاح العمومي المرتبط به على سلسلة الكتل. وهذا يختلف عن المعرفات التقليدية التي تتطلب أطرافًا ثالثة للتوثيق. + +## كيف يمكن للمعرِّفات و المصادقات اللامركزية أن تمكِّن من تحقيق الهوية اللامركزية؟ {#how-decentralized-identifiers-and-attestations-enable-decentralized-identity} + +الهوية اللامركزية هي الفكرة القائلة بأن المعلومات المتصلة بالهوية ينبغي أن تكون ذاتية التحكم وأن تكون خاصة ومحمولة، على أن تكون المعرفات والمصادقات اللامركزية هي كتل البناء الأساسية. + +في سياق الهوية اللامركزية، فإن المصادقات (المعروفة أيضًا باسم [بيانات الاعتمادات القابلة للتحقق](https://www.w3.org/TR/vc-data-model/)) هي مطالبات مضادة للتلاعب، ويمكن التحقق من تشفيرها، وتقدمها جهة الإصدار. كل مصادقة أو بيانات اعتماد قابلة للتحقق منها، صادرة من كيان (منظمة مثلًا)، تكون مرتبطة بالهوية اللامركزية (DID) لديها. + +نظرًا لأن الهويات اللامركزية (DID) تكون مخزنة على سلسلة الكتل، يمكن لأي شخص التحقق من المصادقة من خلال التحقق من الهوية اللامركزية لجهة الإصدار على إثيريوم. تعمل سلسلة كتل إثيريوم بشكل أساسي كدليل عالمي يمكنه التحقق من الهويات اللامركزية (DID) المرتبطة بكيانات معينة. + +وجود المعرفات اللامركزية هو السبب في أن المصادقات ذاتية التحكم ويمكن التحقق منها. وحتى لو لم تعد جهة الإصدار موجودة، فإن صاحبها لديه دائمًا الدليل على مصدر الشهادة وصحتها. + +كما أن المعرفات اللامركزية أمر بالغ الأهمية لحماية خصوصية المعلومات الشخصية من خلال الهوية اللامركزية. فمثلًا، إذا قدم شخص ما دليلًا على مصادقة ما (رخصة قيادة)، لا يحتاج الطرف المتحقق إلى فحص صحة المعلومات في الدليل. بدلًا من ذلك، لا يحتاج المتحقق إلا إلى ضمانات مشفرة لصحة المصادقة وهوية المؤسسة المصدرة لها لتحديد ما إذا كان الدليل صحيحا. + +## أنواع المصادقات في الهوية اللامركزية {#types-of-attestations-in-decentralized-identity} + +تختلف كيفية تخزين المعلومات المتعلقة بالمصادقة وكيفية استرجاعها في نظام الهوية المستند إلى إثيريوم عن الإدارة التقليدية للهوية. وفيما يلي نظرة عامة على مختلف النُهج المتبعة في إصدار المصادقات وتخزينها والتحقق منها في نظم الهوية اللامركزية: + +### مصادقات خارج السلسلة {#off-chain-attestations} + +يتمثل أحد المخاوف المتعلقة بتخزين المصادقات في السلسلة في أنها قد تحتوي على معلومات يرغب الأفراد في الحفاظ على خصوصيتها. الطبيعة العامة لسلسلة كتل إثيريوم تجعلها غير جذابة لتخزين مثل هذه المصادقات. + +لذا يكمن الحل في إصدار مصادقات، يحتفظ بها المستخدمون خارج سلسلة في المحافظ الرقمية، ولكنها موقّعة بهوية لامركزية من الجهة المصدِّرة ومخزنة على السلسلة. هذه المصادقات مشفرة [كرموز JSON Web مميزة](https://en.wikipedia.org/wiki/JSON_Web_Token) وتحتوي على التوقيع الرقمي للجهة المصدِّرة - وهو ما يسمح بسهولة التحقق من المطالبات من خارج السلسلة. + +هذا سيناريو افتراضي لشرح المصادقات خارج السلسلة: + +1. تُصدِر الجامعة (الجهة المصدِّرة) شهادة (شهادة أكاديمية رقمية)، وتوقعها بالمفاتيح الخاصة بها، ثم تصدر هذه الشهادة إلى Bob (صاحب الهوية). + +2. فيما بعد يتقدم Bob للحصول على وظيفة ويرغب في إثبات مؤهلاته الأكاديمية لصاحب عمل، ولذلك فهو يشارك الشهادة من محفظته المتنقلة. وعندئذ يمكن للشركة (المتحقق) أن تؤكد صحة هذه المصادقة بالتحقق من الهوية اللامركزية (DID) للجهة المصدرة (أي مفتاحها العمومي على إثيريوم). + +### المصادقات خارج السلسلة مع الوصول المستمر {#offchain-attestations-with-persistent-access} + +بموجب هذا الترتيب، تُحوّل المصادقات إلى ملفات JSON وتُخّزن خارج السلسلة (بشكل مثالي على [منصة تخزين سحابية لامركزية](/developers/docs/storage/) ، مثل IPFS أو Swarm). ومع ذلك، يُخزن [هاش](/glossary/#hash) لملف JSON ضمن السلسلة، ثم يُربط مع الهوية اللامركزية عبر سجل على السلسلة. ويمكن أن تكون الهوية اللامركزية مرتبطة بالجهة المصدرة للمصادقة أو الجهة المستلمة لها. + +هذا النهج يمكّن المصادقات من الحصول على استمرارية قائمة على سلسلة الكتل، مع الحفاظ على معلومات المطالبات مشفرة وقابلة للتحقق منها. كما أنه يسمح بالكشف الانتقائي لأن حامل المفتاح الخاص يستطيع فك تشفير المعلومات. + +### المصادقات ضمن السلسلة {#onchain-attestations} + +المصادقات ضمن السلسلة موجودة في [العقود الذكية](/developers/docs/smart-contracts/) على سلسلة كتل إثيريوم. العقد الذكي (بصفته سجلًا) سيضع خريطة للمصادقة على معرف لامركزي مناظر (مفتاح عام) ضمن السلسلة. + +إليك مثال عملي لشرح كيفية عمل المصادقات ضمن السلسلة: + +1. تخطط شركة (XYZ Corp) لبيع أسهم الملكية باستخدام عقد ذكي ولكنها تريد فقط المشترين الذين قد أكملوا التحقق من خلفيتهم. + +2. يمكن لشركة XYZ Corp أن يتم لديها فحص الخلفية لإصدار المصادقات ضمن السلسلة على إثيريوم. تشهد هذه المصادقة بأن شخصًا ما قد اجتاز عملية التحقق من الخلفية دون الكشف عن أي معلومات شخصية. + +3. العقد الذكي لبيع الأسهم يمكنه التحقق من عقد التسجيل لمعرفة هويات المشترين الذين تم فحصهم، ممكنًا العقد الذكي من تحديد من يُسمح له بشراء الأسهم أم لا. + +### الرموز المميزة الثابتة والهوية {#soulbound} + +[الرموز المميزة الثابتة](https://vitalik.ca/general/2022/01/26/soulbound.html) (NFTs) غير القابلة للتحويل يمكن استخدامها لجمع معلومات فريدة من نوعها في محفظة معينة. مما يخلق بطريقة فعالة هوية فريدة ضمن السلسلة مرتبطة بعنوان معين على إثيريوم يمكن أن يشمل الرموز المميزة التي تمثل الإنجازات ( مثل الانتهاء من بعض الدورات التدريبية على الإنترنت أو اجتياز حد أدنى للنتيجة في اللعبة) أو المشاركة المجتمعية. + +## فوائد الهوية اللامركزية {#benefits-of-decentralized-identity} + +1. تؤدي الهوية اللامركزية إلى زيادة التحكم الفردي على المعلومات المحددة للهوية. يمكن التحقق من المعرفات والمصادقات اللامركزية دون الاعتماد على السلطات المركزية وخدمات الأطراف الثالثة. + +2. تسهل الحلول اللامركزية للهوية طريقة موثوقة وسلسة وتحمي الخصوصية للتحقق من هوية المستخدم وإدارتها. + +3. تستفيد الهوية اللامركزية من تكنولوجيا سلاسل الكتل التي تؤسس الثقة بين مختلف الأطراف وتوفر ضمانات تشفير لإثبات صحة المصادقات. + +4. الهوية اللامركزية تجعل بيانات الهوية متنقلة. يخزن المستخدمون المصادقات والمعرفات في محفظة محمولة ويمكنهم مشاركتها مع أي طرف يختارونه. لا تخزن المعرفات والمصادقات اللامركزية في قاعدة بيانات مقفلة للمنظمة المصدرة. + +5. ينبغي للهوية اللامركزية أن تعمل بشكل جيد مع تكنولوجيات المعرفة الصفرية التي ستمكن الأفراد من إثبات امتلاكهم لشيء ما، أو إثبات فعلهم لعمل ما دون الكشف عن ماهية هذا الشيء. يمكن أن يصبح ذلك وسيلة قوية للجمع بين الثقة والخصوصية فيما يتعلق بتطبيقات مثل التصويت. + +6. تمكن الهوية اللامركزية آليات مكافحة Sybil لتحديد الوقت الذي يحاول فيه أحد الأشخاص أن يتظاهر بأنه عدة أشخاص للتلاعب أو الاحتيال على بعض الأنظمة. + +## حالات استخدامات الهوية اللامركزية {#decentralized-identity-use-cases} + +للهوية اللامركزية العديد من حالات الاستخدامات الممكنة: + +### 1. عمليات تسجيل الدخول العام {#universal-dapp-logins} + +يمكن أن تساعد الهوية اللامركزية في استبدال عمليات تسجيل الدخول المستندة إلى كلمة المرور [بمصادقة لامركزية](https://www.ibm.com/blogs/blockchain/2018/10/decentralized-identity-an-alternative-to-password-based-authentication/). يمكن لمقدمي الخدمات إصدار مصادقات للمستخدمين، والتي يمكن تخزينها في محفظة إثيريوم. ومن أمثلة المصادقة [NFT](/nft/) التي تمنح المالك حق الوصول إلى مجتمع ما على الإنترنت. + +ستقوم وظيفة [تسجيل الدخول باستخدام إثيريوم](https://login.xyz/) حينئذ بتمكين الخوادم لتأكيد حساب المستخدم في إثيريوم والحصول على المصادقة المطلوبة من عنوان الحساب الخاص بهم. وهذا يعني أنه يمكن للمستخدمين الوصول إلى المنصات والمواقع دون الحاجة إلى حفظ كلمات المرور الطويلة وتحسين تجربة المستخدمين على الإنترنت. + +### ٢. مصادقة KYC {#kyc-authentication} + +يتطلب استخدام العديد من الخدمات على الإنترنت أن يقدم الأفراد مصادقات وبيانات اعتماد، مثل رخصة قيادة أو جواز سفر وطني. لكن هذا النهج يثير مشكلات عدّة لأن معلومات المستخدمين الخاصة يمكن أن تتعرض للخطر، ولأن مقدمي الخدمات لا يستطيعون التحقق من صحة المصادقات. + +تسمح الهويّة اللامركزية للشركات بتجنب العمليات التقليدية [ اعرف زبونك (KYC)](https://en.wikipedia.org/wiki/Know_your_customer) والتحقق من هويات المستخدم عن طريق بيانات الاعتماد القابلة للتحقق. مما يقلل من تكلفة إدارة شؤون الهوية ويحول دون استخدام الوثائق المزورة. + +### 3. التصويت و المجتمعات على الإنترنت {#voting-and-online-communities} + +يشكل التصويت على الإنترنت ووسائل التواصل الاجتماعي تطبيقين جديدين للهوية اللامركزية. يُعد التصويت على الإنترنت عرضة للتلاعب، ولا سيما إذا كانت الجهات الفاعلة الخبيثة تنشئ هويات مزيفة للتصويت. يُمكن أن يؤدي الطلب من الأفراد تقديم مصادقات ضمن السلسلة إلى تحسين نزاهة عمليات التصويت على الإنترنت. + +كما يمكن للهوية اللامركزية أن تساعد على إنشاء مجتمعات على الإنترنت خالية من الحسابات المزورة. فعلى سبيل المثال، قد يتعين على كل مستخدم أن يوثق هويته باستخدام نظام هوية ضمن السلسلة، مثل دائرة أسماء إثيريوم، مما يقلل من إمكانية وجود البوتات. + +### 4. الحماية من Sybil {#sybil-protection} + +تشير هجمات Sybil إلى أن أفراد يخدعون النظام بإيهامه أنهم أشخاص عديدون بهدف زيادة نفوذهم. [تطبيقات طلب المنح](https://gitcoin.co/grants/) التي تستخدم [التصويت الرباعي](https://www.radicalxchange.org/concepts/plural-voting/) معرضة لهجمات Sybil لأن قيمة المنحة تزداد عندما يصوت المزيد من الأفراد لها. مما يحفز المستخدمين على تقسيم مساهماتهم عبر العديد من الهويات. تساعد الهويات اللامركزية على منع ذلك بزيادة العبء على كل مشارك لإثبات أنه إنسان بالفعل وليس بوت، على الرغم من أنه لا يتطلب في كثير من الأحيان الكشف عن معلومات خاصة محددة. + +## استخدام الهوية اللامركزية {#use-decentralized-identity} + +هناك العديد من المشاريع الطموحة التي تستخدم إثريوم كأساس لحلول الهوية اللامركزية: + +- **[خدمة اسم إثيريوم (ENS)](https://ens.domains/)** - _نظام تسمية لامركزي ضمن السلسلة، ومعرّفات مقروءة آليا، مثل عناوين محفظة إثيريوم، و محتوى الهاش، والبيانات الوصفية._ +- **[SpruceID](https://www.spruceid.com/)** - _مشروع للهوية اللامركزية يسمح للمستخدمين بالتحكم في الهوية الرقمية مع حسابات إثيريوم وملفات ENS بدلا من الاعتماد على خدمات طرف ثالث._ +- **[خدمة مصادقة إثيريوم (EAS)](https://attest.sh/)** - _دفتر الأستاذ/البروتوكول اللامركزي لعمل المصادقات ضمن السلسلة أو خارج السلسلة بخصوص أي شيء._ +- **[إثبات الإنسانية](https://www.proofofhumanity.id)** - _إثبات الإنسانية (أو poH) هو نظام للتحقق من الهوية الاجتماعية مبني على إثيريوم._ +- **[BrightID](https://www.brightid.org/)** - _ شبكة الهوية الاجتماعية اللامركزية مفتوحة المصدر تسعى إلى إصلاح التحقق من الهوية من خلال إنشاء مخطط اجتماعي وتحليله._ +- **[ جواز إثبات الشخصية](https://proofofpersonhood.com/)** - _مجمع للهوية الرقمية اللامركزية_ + +## قراءة إضافية {#further-reading} + +### مقالات {#articles} + +- [حالات استخدام سلسلة الكتل: سلسلة الكتل في الهوية الرقمية](https://consensys.net/blockchain-use-cases/digital-identity/) — _ConsenSys_ +- [ما هو إثريوم ERC725؟ Self-Sovereign Identity Management on the Blockchain](https://cryptoslate.com/what-is-erc725-self-sovereign-identity-management-on-the-blockchain/) — _Sam Town_ - إدارة الهُوِيَّة ذات السيادة الذاتية على سلسلة الكتل +- [How Blockchain Could Solve the Problem of Digital Identity](https://time.com/6142810/proof-of-humanity/) — _Andrew R. Chow_ - كيف يمكن لسلسلة الكتل أن تحل مشكلة الهُوِيَّة الرقمية +- [What Is Decentralized Identity And Why Should You Care? (ما هي الهوية اللامركزية ولماذا عليك أن تهتم بها؟)](https://web3.hashnode.com/what-is-decentralized-identity) — _إيمانويل أووسيكا_ - + +### مقاطع الفيديو {#videos} + +- [الهوية اللامركزية (جلسة Bonus ديم Livestream)](https://www.youtube.com/watch?v=ySHNB1za_SE&t=539s) - _فيديو تفسيري عظيم عن الهوية اللامركزية من تقديم أندرياس أنتونوبولوس_ +- [تسجيل الدخول باستخدام إثيريوم والهوية اللامركزية مع Ceramic، وIDX، وReact و 3ID Connect](https://www.youtube.com/watch?v=t9gWZYJxk7c) - _درس تعليمي على يوتيوب عن بناء نظام لإدارة الهوية لإنشاء، وقراءة، وتحديث الملف الشخصي للمستخدم باستخدام محفظة إثيريوم من تقديم نادر دابيت_ +- [BrightID - الهوية اللامركزية على إثيريوم](https://www.youtube.com/watch?v=D3DbMFYGRoM) - _حلقة تسجيلات Bankless تناقش BrightID، حل لا مركزي للهوية لإثيريوم_ +- [الانترنت خارج السلسلة: الهوية لامركزية & وبيانات الاعتماد التي يمكن التحقق منها](https://www.youtube.com/watch?v=EZ_Bb6j87mg) — EthDenver 2022 عرض من إيفين ماكملين + +### المجتمعات {#communities} + +- [ERC-725 Alliance on GitHub](https://github.com/erc725alliance) — _داعمو معيار ERC725 لإدارة الهوية على سلسلة كتل إثيريوم_ +- [خادم SpruceID Discord](https://discord.com/invite/Sf9tSFzrnt) — _مجتمع للمتحمسين والمبرجمين الذين يعملون على تسجيل الدخول من خلال إثيريوم _ +- [Veramo Labs](https://discord.gg/sYBUXpACh4) - _مجتمع من المبرجمين يساهم في بناء إطار عمل للبيانات القابلة للتحقق منها للتطبيقات_ diff --git a/src/content/translations/ar/defi/index.md b/src/content/translations/ar/defi/index.md new file mode 100644 index 00000000000..8333492c416 --- /dev/null +++ b/src/content/translations/ar/defi/index.md @@ -0,0 +1,352 @@ +--- +title: التمويل اللامركزي (DeFi) +description: نظرة عامة حول التمويل اللامركزي على إثيريوم +lang: ar +template: use-cases +emoji: ":money_with_wings:" +image: ../../../../assets/use-cases/defi.png +alt: شعار إثيريوم مصنوع من قطع الليجو. +sidebarDepth: 2 +summaryPoint1: "• بديل عالمي مفتوح عن النظام المالي الحالي." +summaryPoint2: المنتجات التي تسمح لك بالاقتراض، والادخار، والاستثمار، والتجارة، والمزيد. +summaryPoint3: استنادًا إلى التكنولوجيا مفتوحة المصدر التي يمكن لأي شخص أن يبرمج باستخدامها. +--- + +التمويل اللامركزى نظام مالي عالمي مفتوح تم بناؤه لعصر الإنترنت - وهو بديل لنظام غامض، يخضع للتحكم الصارم، ومتوحد بواسطة بنية تحتية وعمليات دامت عقودا من الزمن. وهو يمنحك التحكم والاطلاع الكامل على أموالك. كما يمنحك فرصة للتعامل مع الأسواق العالمية و بدائل للعملة المحلية أو الخيارات المصرفية لديك. منتجات التمويل اللامركزي DeFi تتيح الخدمات المالية لأي شخص لديه اتصال بالإنترنت وهي مملوكة ومصانة بشكل أساسي من قبل مستخدميها. حتى الآن تدفقت عملات رقمية بقيمة عشرات المليارات من الدولارات عبر تطبيقات DeFi التي تنمو كل يوم. + +## ما هو التمويل اللامركزي؟ {#what-is-defi} + +التمويل اللامركزي هو مصطلح إجمالي للمنتجات والخدمات المالية التي يمكن الوصول إليها بواسطة أي شخص يمكنه استخدام إثيريوم - أي شخص لديه اتصال بالإنترنت. مع التمويل اللامركزي، الأسواق مفتوحة دائمًا ولا توجد سلطات مركزية يمكنها منع المدفوعات أو منعك من الوصول إلى أي شيء. الخدمات التي كانت بطيئة سابقًا ومعرضة لخطر الخطأ البشري، أصبحت تلقائية وأكثر أمانًا الآن بعد أن تم التعامل معها بواسطة رمز يمكن لأي شخص فحصه والتحقق منه. + +هناك اقتصاد رقمي مزدهر، حيث يمكنك الإقراض، والاقتراض، والبيع/الشراء، وكسب الفائدة، والمزيد. استخدم الأرجنتينيون المتمرسون في مجال التشفير التمويل اللامركزي للهروب من التضخم المعوق. بدأت الشركات في دفع أجور موظفيها في الوقت الفعلي. حتى أن بعض الناس اقترضوا وسددوا قروضًا بملايين الدولارات دون الحاجة إلى أي هوية شخصية. + + + +## التمويل اللامركزي مقابل التمويل التقليدي {#defi-vs-tradfi} + +واحدة من أفضل الطرق لمعرفة إمكانات التمويل اللامركزي هي فهم المشاكل الموجودة اليوم. + +- لا يتم منح بعض الأشخاص حق إعداد حساب مصرفي أو استخدام الخدمات المالية. +- يمكن أن يؤدي عدم الوصول إلى الخدمات المالية إلى منع الأشخاص من أن يصبحوا مؤهلين للتوظيف. +- يمكن للخدمات المالية أن تمنعك من الحصول على مدفوعاتك. +- تعتبر بياناتك الشخصية من الرسوم الخفية للخدمات المالية. +- يمكن للحكومات والمؤسسات المركزية إغلاق الأسواق حسب الرغبة. +- غالبًا ما تقتصر ساعات التداول على ساعات العمل في منطقة زمنية محددة. +- يمكن أن تستغرق تحويلات الأموال أيامًا بسبب العمليات البشرية الداخلية. +- هناك علاوة على الخدمات المالية لأن المؤسسات الوسيطة بحاجة إلى اقتطاعها. + +### مقارنة {#defi-comparison} + +| DeFi | التمويل التقليدي | +| --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | +| أنت تملك أموالك. | أموالك تحتجزها الشركات. | +| أنت تتحكم في أين تذهب أموالك وكيف يتم إنفاقها. | عليك أن تثق في أن الشركات لا تسيء إدارة أموالك، مثل إقراض المقترضين المحفوفين بالمخاطر. | +| يتم تحويل الأموال في غضون دقائق. | قد تستغرق المدفوعات أيامًا بسبب العمليات اليدوية. | +| نشاط المعاملة مجهول الهوية. | يرتبط النشاط المالي ارتباطًا وثيقًا بهويتك. | +| التمويل اللامركزي مفتوح لأي شخص. | يجب عليك التقدم بالطلب لاستخدام الخدمات المالية. | +| الأسواق مفتوحة دائمًا. | الأسواق تغلق لأن الموظفين يحتاجون إلى فترات راحة. | +| إنها مبنية على الشفافية - يمكن لأي شخص الاطلاع على بيانات المنتج وفحص كيفية عمل النظام. | المؤسسات المالية عبارة عن دفاتر مغلقة: لا يمكنك أن تطلب الاطلاع على سجل قروضها، وسجل أصولها المدارة، وما إلى ذلك. | + + + استكشف تطبيقات التمويل اللامركزي + + +## لقد بدأت مع عملة بيتكوين... {#bitcoin} + +من نواح عدة، كانت عملة بيتكوين أول تطبيق للتمويل اللامركزي. تتيح لك عملة بيتكوين بالفعل امتلاك القيمة والتحكم فيها وإرسالها إلى أي مكان حول العالم. وهي تفعل ذلك بواسطة تقديم طريقة لعدد كبير من الأشخاص، الذين لا يثقون ببعضُهم البعض، كي يوافقوا على سجل الحسابات دون الحاجة لوسيط موثوق. عملة بيتكوين مفتوحة لأي شخص ولا أحد يملك سلطة تغيير قواعده. قواعد عملة بيتكوين، مثل الندرة والانفتاح، مكتوبة في التكنولوجيا. وهي لا تشبه التمويل التقليدي حيث يمكن للحكومات طباعة المال مما يقلل قيمة مدخراتك، أو يمكن للشركات إغلاق الأسواق. + +إثيريوم يستند على هذه المبادئ. كما هو الحال مع عملة بيتكوين، فإن القواعد لا يمكن أن تتغير عليكم والجميع يمكنه الوصول. لكنها أيضا تجعل هذه الأموال الرقمية قابلة للبرمجة، باستخدام [العقود الذكية](/glossary#smart-contract)، وبالتالي ستتمكن من الذهاب إلى ما هو أبعد من التخزين وإرسال القيمة. + + + +## الأموال القابلة للبرمجة {#programmable-money} + +يبدو هذا غريبًا... "لماذا أريد برمجة مالي"؟ ومع ذلك، فهذه ميزة افتراضية للرموز على إثيريوم. يمكن لأي شخص برمجة المنطق في المدفوعات. لذا يمكنك الحصول على تحكم وأمان عملة بيتكوين فضلاً عن الخدمات التي تقدمها المؤسسات المالية. هذا يتيح لك القيام بأشياء مع العملات الرقمية لا يمكنك القيام بها مع عملة بيتكوين مثل الإقراض والاقتراض، وجدولة المدفوعات، والاستثمار في صناديق الفهرسة والمزيد. + + +
استكشف اقتراحاتنا لتطبيقات التمويل اللامركزي التي يمكن تجربتها إذا كنت جديداً على إثيريوم.
+ + استكشف النظام المالي اللامركزي (DeFi) + + + +## ما الذي يمكنك أن تفعله بالتمويل اللامركزي؟ {#defi-use-cases} + +هناك بديل لامركزي لمعظم الخدمات المالية. لكن إثيريوم أيضاً يخلق فرصاً لإنشاء منتجات مالية جديدة تماماً. وهذه قائمة متزايدة باستمرار. + +- [إرسال المال إلى جميع أنحاء العالم](#send-money) +- [تدفق المال في جميع أنحاء العالم](#stream-money) +- [الوصول إلى العملات المستقرة](#stablecoins) +- [صناديق الاقتراض بضمان إضافي](#lending) +- [الاقتراض دون ضمان إضافي](#flash-loans) +- [بدء عمليات توفير العملات المشفرة](#saving) +- [الرموز المميزة للتجارة](#swaps) +- [تنمية محفضتك](#investing) +- [تمويل الأفكار الخاصة بك](#crowdfunding) +- [شراء التأمين](#insurance) +- [إدارة محفظتك](#aggregators) + + + +### إرسال المال بسرعة في جميع أنحاء العالم {#send-money} + +كسلسلة كتل، صممت إثيريوم لإرسال المعاملات بطريقة آمنة وعالمية. مثل عملة بيتكوين، إيثريوم يجعل إرسال الأموال حول العالم سهلاً مثل إرسال البريد الإلكتروني. فقط أدخل اسم الطرف المستلم [اسم ENS](/nft/#nft-domains) (مثل bob.eth) أو عنوان الحساب الخاص به من محفظتك، والمدفوعات الخاص بك سوف تذهب (عادةً) إليه مباشرة في دقائق. لإرسال أو تلقي المدفوعات، ستحتاج إلى [محفظة](/wallets/). + + + شاهد تطبيقات الدفع اللامركزية + + +#### تدفق المال في جميع أنحاء العالم... {#stream-money} + +يمكنك أيضًا دفق الأموال عبر إثيريوم. يتيح لك ذلك دفع راتب شخص ما بالثانية، مما يتيح له الحصول على المال كلما احتاجه. أو تأجير شيء بالثانية مثل خزانة تخزين أو دراجة كهربائية. + +وإذا كنت لا تريد إرسال أو دفق عملة [ETH](/eth/) بسبب حجم التغير في قيمتها، فهناك عملات بديلة على إثيريوم: العملات المستقرة. + + + +### الوصول إلى العملات المستقرة {#stablecoins} + +تقلبات العملات الرقمية هي مشكلة بالنسبة لكثير من المنتجات المالية والإنفاق العام. قام مجتمع التمويل اللامركزي بحل هذه المشكلة بواسطة العملات المستقرة. تبقى قيمتها مرتبطة بأصل آخر، عادةً يكون عملة شائعة مثل الدولارات. + +عملات مثل Dai أو USDC لديها قيمة تظل في حدود بضع سنتات قليلة من الدولار. ما يجعلها مثالية للكسب أو البيع بالتجزئة. وقد استخدم كثير من الناس في أمريكا اللاتينية العملات المستقرة كوسيلة لحماية مدخراتهم في وقت يتسم بقدر كبير من عدم اليقين إزاء عملاتهم الصادرة عن الحكومات. + + + المزيد حول العملات المستقرة + + + + +### الاقتراض {#lending} + +يأتي اقتراض الأموال من مقدمي الخدمات اللامركزية في نوعين رئيسيين. + +- النظراء: ويعني أن المقترض سيقترض من مقرض معين مباشرة. +- ويقوم المقرضون على أساس التجميع بتوفير أموال (سيولة) لمجمع يمكن للمقترضين الاقتراض منه. + + + اطلع على تطبيقات الاقتراض اللامركزية + + +هناك العديد من المزايا لاستخدام المقرض اللامركزي... + +#### الاقتراض مع الخصوصية {#borrowing-privacy} + +اليوم، تتمحور عملية إقراض واقتراض الأموال حول الأفراد المعنيين. تحتاج البنوك قبل إقراض الأموال إلى معرفة ما إذا كان من المرجح أن تسدده. + +يعمل الإقراض اللامركزي دون أن يضطر أي من الطرفين إلى تحديد هويته. بدلا من ذلك، يجب على المقترض أن يقدم ضمانة احتياطية يحصل عليها المقرض تلقائيًا إذا لم يسدد قرضه. قد يقبل بعض المقرضين بـ NFT كضمان إضافي. NFT هي صكوك لأصل فريد، لوحة فنية مثلًا. [المزيد حول NFT](/nft/) + +هذا يسمح لك باقتراض المال دون شيكات ائتمانية أو تسليم معلومات خاصة. + +#### الوصول إلى الصناديق العالمية {#access-global-funds} + +عندما تتعامل مع مقرض لامركزي تحصل على الأموال المودعة من جميع أنحاء العالم، ليس فقط الأموال الموجودة في عهدة بنك أو مؤسسة محددة. مما يجعل الحصول على القروض أيسر ويحسن معدلات الفائدة. + +#### الكفاءات الضريبية {#tax-efficiencies} + +يتيح الاقتراض إمكانية الوصول إلى الأموال التي تحتاجها دون الحاجة إلى بيع ETH الخاص بك (حدث خاضع للضريبة). بدلاً من ذلك، يمكنك استخدام ETH كضمانة إضافية للحصول على قرض بالعملة المستقرة. مما يعطيك التدفق النقدي الذي تحتاجه ويسمح لك بالحفاظ على ETH. العملات المستقرة هي رموز مميزة أكثر جدوى عندما نحتاج إلى النقود لأنها لا تتقلب في القيمة مثل ETH. [المزيد حول العملات المستقرة](#stablecoins) + +#### القروض السريعة {#flash-loans} + +القروض السريعة هي نموذج تجريبي أكثر للإقراض اللامركزي الذي يسمح بالاقتراض دون ضمانة إضافية أو دون تقديم أي معلومات شخصية. + +فهي ليست متاحة على نطاق واسع للأشخاص غير التقنيين الآن، ولكنها تشير إلى ما قد يكون ممكنا للجميع في المستقبل. + +حيث تعمل على أساس أن القرض يؤخذ ويسدد في إطار نفس المعاملة. وفي حال عدم إمكانية الرد، فإن المعاملة تعود كما لو لم يحدث أي شيء نهائيًا. + +ويتم الاحتفاظ بالصناديق المستخدمة عادةً في مجمعات للسيولة (مجمعات كبيرة من الصناديق تستخدم في الاقتراض). وفي حال لم تكن هذه الصناديق مستخدمة في لحظة محددة، فإن ذلك يتيح فرصة لشخص ما لاقتراض هذه الصناديق. والقيام بالأعمال التجارية بها، ثم ردها بالكامل حرفيًا في نفس الوقت الذي تم فيه الاقتراض. + +وهذا يعني أن الكثير من المنطق يجب أن يكون متضمنًا في معاملة مشبوهة للغاية. ومن الأمثلة البسيطة على ذلك شخص يأخذ قرضًا سريعًا لاقتراض كم كبير من أصل بسعر واحد حتى يتمكن من بيعه في بورصة مختلفة بسعر أعلى. + +لذلك سيحدث ضمن المعاملة الواحدة ما يلي: + +- فلنفترض أنك اقترضت المبلغ X من $asset بسعر 1.00 دولار من البورصة A +- ثم بعت الكم X من $asset في البورصة B بسعر 1.10 دولار +- ثم رددت القرض إلى البورصة A +- وبذلك تكون حققت أرباحًا مخصوم منها رسم المعاملة + +في حال انخفضت توريدات البورصة B فجأةً، ولم يتمكن المستخدم من الشراء بما يكفي لتغطية القرض الأصلي، فببساطة ستفشل المعاملة. + +لكن لتتمكن من القيام بالمثال المذكور أعلاه في عالم التمويل التقليدي، ستحتاج إلى مبلغ هائل من المال. ولا يتاح هذا النوع من استراتيجيات كسب الأموال إلا لمن لديهم ثروات قائمة. القروض السريعة مثال على مستقبل لا يكون فيه وجود المال شرطًا مسبقًا ضرورياً لكسب المال. + +[المزيد حول القروض السريعة](https://aave.com/flash-loans/) + + + +### ابدأ بالكسب مع العملات الرقمية {#saving} + +#### الإقراض {#lending} + +يمكنك كسب فائدة على العملات الرقمية عن طريق إقراضها ثم ستشاهد أموالك تنمو مباشرة. حاليًا معدلات الفائدة أعلى بكثير مما قد تحصل عليه من البنوك المحلية (لو كنت محظوظًا بما يكفي لكي تتمكن من الوصول لأحدها). مثلا: + +- فلنفترض أنك أقرضت 100 Dai، [وهي عملة تابعة](/stablecoins/)، إلى منتج مثل Aave. +- تحصل على 100 Aave Dai (aDai) وهو رمز مميز يمثل قرض Dai الذي منحته. +- ستزيد قيمة aDai لديك بناءً على معدلات الفائدة ويمكنك أن ترى رصيدك ينمو في محفظتك. اعتمادا على APR، سيظهر رصيد محفظتك مثل 100.1234 بعد بضعة أيام أو حتى ساعات! +- ثم يمكنك سحب مبلغ من Dai القياسي يعادل رصيد aDai الخاص بك في أي وقت. + + + اطلع على التطبيقات اللامركزية للإقراض + + +#### يانصيب دون خسارة {#no-loss-lotteries} + +اليانصيب دون خسارة، مثل PoolTogether هي طريقة جديدة ممتعة ومبتكرة لتوفير المال. + +- أنت تشتري 100 بطاقة باستخدام 100 رمز مميز من عملة Dai. +- وتتلقى 100 plDai تمثل 100 بطاقة. +- لو تم سحب إحدى بطاقاتك باعتبارها الفائزة، فإن رصيدك من plDai سيزداد بمقدار مبلغ مجمع الجائزة. +- إذا لم تفُز، سيتم ترحيل الـ 100 plDai الخاصة بك إلى سحب الأسبوع القادم. +- ثم يمكنك سحب مبلغ من Dai القياسي بحيث يعادل رصيدك من plDai في أي وقت. + +ينشأ مجمع الجوائز من خلال جميع الفوائد التي يولدها إقراض ودائع البطاقات كما هو الحال في مثال الإقراض أعلاه. + + + جرب PoolTogether + + + + +### تبادل الرموز المميزة {#swaps} + +يوجد الآلاف من الرموز المميزة على إثيريوم. تسمح لك البورصات اللامركزية (DEXs) بتجارة الرموز المميزة المختلفة متى أردت. لن تفقد أبدًا التحكم في أصولك. هذا يشبه تغيير العملات عند زيارة بلد مختلف. لكن الفرق هو أن نسخة التمويل اللامركزي لا تغلق أبدًا. ما يعني أن أسواق \تعمل بنظام 24/7، لمدة 365 يومًا في السنة، مع ضمانات تكنولوجية تتيح إمكانية دائمة لوجود شخص يقبل المتاجرة. + +على سبيل المثال، إذا كنت ترغب في استخدام اليانصيب دون خسارة PoolTogether (الموصوف أعلاه)، فستحتاج إلى رمز مميز مثل Dai أو USDC. تسمح لك هذا البورصات اللامركزية باستبدال عملة ETH مقابل هذه الرموز المميزة واستردادها لاحقًا عندما تنتهي. + + + اطلع على بورصات الرموز المميزة + + + + +### التجارة المتقدمة {#trading} + +هناك خيارات أكثر تقدماً للمتداولين الذين يفضلون تحكمًا أكبر. تداول الأوامر المحدودة، والتداول المستمر، والتداول الهامشي والمزيد كلها ممكنة. مع التداول اللامركزي ستتمكن من الوصول إلى السيولة العالمية، حيث الأسواق لا تغلق أبدًا، ولديك تحكم دائم بأصولك. + +فعندما تُستخدم البورصة المركزية، عليك أن تودع أصولك قبل التداول، وأن تثق بأن هذه البورصات ستعتني بالأصول. عندما تكون أصولك مودعة، فهي معرضة للخطر لأن البورصات المركزية هي أهداف جذابة للقراصنة. + + + اطلع على التطبيقات اللامركزية للتداول + + + + +### تنمية محفضتك {#investing} + +هناك منتجات لإدارة الأموال على إثيريوم تحاول تنمية حافظتك على أساس استراتيجية من اختيارك. بشكل تلقائي ومفتوح للجميع، ولا يحتاج إلى مدير بشري يقتطع جزءًا من أرباحك. + +ومن الأمثلة الجيدة على ذلك [DeFi Pluse Index fund (DPI)](https://defipulse.com/blog/defi-pulse-index/). هذا صندوق يعيد توازن الرصيد تلقائيًا لضمان أن حافظتك دائمًا تتضمن [أعلى عملات التمويل اللامركزي عن طريق رأسمالية السوق](https://www.coingecko.com/en/defi). لا تحتاج أبدًا إلى إدارة أي من التفاصيل ويمكنك السحب من الصندوق متى ما رغبت. + + + شاهد التطبيقات اللامركزية للاستثمار + + + + +### تمويل الأفكار الخاصة بك {#crowdfunding} + +إثيريوم هو منصة مثالية للتمويل الجماعي: + +- يمكن للممولين المحتملين أن يأتوا من أي مكان - إثيريوم ورموزها المميزة مفتوحة لأي شخص، في أي مكان في العالم. +- إنه يتمتع بالشفافية بحيث يستطيع جامعو الأموال أن يثبتوا مقدار الأموال التي تم جمعها. يمكنك حتى تتبع كيفية إنفاق هذه الأموال لاحقًا وفق الخط المحدد. +- ويمكن لجامعي الأموال إعداد الأموال تلقائيًا، على سبيل المثال، إذا كان هناك موعد نهائي محدد وحد أدنى للمبلغ لم يتم الوفاء به. + + + اطلع على التطبيقات اللامركزية لجمع الأموال + + +#### التمويل الرباعي {#quadratic-funding} + +إن إثيريوم عبارة عن برنامج مفتوح المصدر وحتى الآن قد تم تمويل جزء كبير من العمل من جانب المجتمع. وقد أدى هذا إلى نمو نموذج جديد مثير للاهتمام لجمع الأموال: التمويل الرباعي. هذا لديه القدرة على تحسين الطريقة التي نمول بها جميع أنواع السلع العامة في المستقبل. + +يضمن التمويل الرباعي أن المشاريع التي تتلقى أكبر قدر من التمويل هي تلك ذات الطلب الأكثر تفرداً. بمعنى آخر ، المشاريع التي تهدف إلى تحسين حياة معظم الناس. إليك كيف يعمل: + +1. هناك مجمع مماثل من الأموال المتبرع بها. +2. تبدأ جولة من التمويل العام. +3. يمكن أن يشير الناس لحاجتهم لمشروع ما بالتبرع له ببعض المال. +4. وبمجرد انتهاء الجولة، يوزع المجمع المماثل على المشاريع. ويحصل أولئك الذين لديهم أكثر طلب فريد على أعلى مبلغ من المجمع المماثل. + +وهذا يعني أن المشروع A مع 100 تبرع بـ 1 دولار، يمكن أن ينتهي به الأمر إلى الحصول على تمويل أكثر من المشروع B مع تبرع واحد قدره 10.000 دولار (اعتمادًا على حجم المجمع المماثل). + +[المزيد حول التمويل الرباعي](https://wtfisqf.com) + + + +### التأمين {#insurance} + +يهدف التأمين اللامركزي إلى جعل التأمين أرخص، وأسرع في الدفع، وأكثر شفافية. ومع المزيد من الأتمتة، تصبح تغطية التأمين ميسورة التكلفة و تغدو المدفوعات أسرع بكثير. والبيانات المستخدمة للبت في المطالبات تتمتع بشفافية تامة. + +يمكن لمنتجات إثيريوم، حالها حال جميع البرامج، أن تعاني من الأخطاء والاستغلال. لذا فإن الكثير من منتجات التأمين الموجودة في المجال تركز على حماية مستخدميها من فقدان أموالهم. إلا أن هناك مشاريع بدأت في بناء تغطية لكل ما يمكن للحياة أن تفاجئنا به. ومن الأمثلة الجيدة على ذلك غطاء Etherisc's Crop الذي يهدف إلى [حماية صغار المزارعين في كينيا من الجفاف والفيضانات](https://blog.etherisc.com/etherisc-teams-up-with-chainlink-to-deliver-crop-insurance-in-kenya-137e433c29dc). ويمكن للتأمين اللامركزي أن يوفر تغطية أرخص للمزارعين الذين يواجهون أسعارًا باهظة في التأمين التقليدي. + + + اطلع على تطبيقات التأمين اللامركزية + + + + +### المجمعون ومديرو الحافظات المالية {#aggregators} + +مع الكثير من الأحداث، ستحتاج إلى طريقة لتتبع جميع استثماراتك، وقروضك، وتداولاتك. هناك مجموعة من المنتجات التي تسمح لك بتنسيق جميع أنشطة التمويل اللامركزي الخاصة بك من مكان واحد. هذا ما تمتاز به البنية المفتوحة للتمويل اللامركزي. يمكن للفرق بناء واجهات تتيح لك الاطلاع على أرصدتك عبر المنتجات، كما يمكنك استخدام ميزاتها أيضًا. قد تجد هذا مفيدًا وأنت تستكشف المزيد حول التمويل اللامركزي. + + + اطلع على التطبيقات اللامركزية للحافظة + + + + +## كيف يعمل التمويل اللامركزي؟ {#how-defi-works} + +يستخدم التمويل اللامركزي العملات الرقمية والعقود الذكية لتوفير خدمات لا تحتاج إلى وسطاء. تعمل المؤسسات المالية، في العالم المالي المعاصر، بصفتها ضامنة للمعاملات. مما يمنح هذه المؤسسات قوة هائلة لأن الأموال تتدفق من خلالها. إضافةً إلى أن المليارات من الأشخاص حول العالم لا يمكنهم حتى إنشاء حساب بنكي. + +في نظام التمويل اللامركزي، يحل العقد الذكي محل المؤسسة المالية في المعاملة. العقد الذكي هو نوع من حساب إثيريوم يمكنه أن يحتفظ بالأموال وإرسالها/استردادها بناءً على شروط معينة. لا يمكن لأحد أن يغير هذا العقد الذكي عندما يكون نشطًا - حيث سيعمل دائمًا كما هو مبرمج. + +العقد المبرم لتقديم بدل مالي أو مصروف جيب، يمكن برمجته لإرسال أموال من الحساب A إلى الحساب B كل يوم جمعة. وسوف يفعل ذلك دائمًا طالما توفرj الأموال المطلوبة لدى الحساب A. ولا يمكن لأحد تغيير العقد، وإضافة الحساب C كمستلم بهدف سرقة الأموال. + +كما أن العقود علنية فأي شخص يمكنه تدقيقها ومراجعتها. وهذا يعني أن العقود السيئة ستخضع غالبًا لتدقيق المجتمع بسرعة كبيرة. + +وهذا يعني أن هناك حاجة حالية إلى الثقة في الأعضاء التقنيين في مجتمع إثيريوم الذين يستطيعون قراءة الكود. المجتمع القائم على المصدر المفتوح يساعد على إبقاء المبرمجين تحت المراقبة، ولكن هذه الحاجة ستتضاءل بمرور الوقت كلما أصبحت قراءة العقود الذكية أسهل، وتم تطوير طرق أخرى لإثبات موثوقية النص البرمجي. + +## إثيريوم والتمويل اللامركزي {#ethereum-and-defi} + +يعد إثيريوم الأساس المثالي للتمويل اللامركزي لعدة أسباب: + +- لا أحد يملك إثيريوم أو العقود الذكية التي تعتمد عليه - وهذا يمنح الجميع فرصة لاستخدام التمويل اللامركزي. وهذا يعني أيضًا أنه لا يمكن لأحد أن يغير القواعد بالنسبة لك. +- منتجات التمويل اللامركزي كلها تتحدث نفس اللغة خلف الكواليس: إثيريوم. وبالتالي يعني أن العديد من المنتجات تعمل معًا بسلاسة. يمكنك إقراض الرموز المميزة للعملات على إحدى المنصات وتداول الرموز المميزة ذات الفائدة في سوق مختلفة باستخدام تطبيق مختلف تمامًا. هذا كأن تكون قادرًا على تحويل نقاط الولاء في البنك الخاص بك إلى أموال. +- توجد الرموز المميزة والعملات الرقمية ضمن بناء إثيريوم، السجل المشترك - الذي يحافظ على تتبع المعاملات والملكية هو أحد ميزات إثيريوم. +- يسمح إثيريوم بحرية مالية كاملة - معظم المنتجات لن تحتجز أموالك أبدًا، مما يتيح لك حرية التحكم بها. + +يمكنك التفكير في التمويل اللامركزي ضمن طبقات: + +1. سلسلة الكتل - يحتوي إثيريوم على تاريخ المعاملات وحالة الحسابات. +2. الأصول - عملة [ETH](/eth/) والرموز المميزة الأخرى (العملات). +3. البروتوكولات - [عقود ذكية](/glossary/#smart-contract) التي تقدم وظيفة، على سبيل المثال خدمة تسمح بالإقراض اللامركزي للأصول. +4. [التطبيقات](/dapps/) - المنتجات التي نستخدمها لإدارة البروتوكولات والوصول إليها. + +## بناء التمويل اللامركزي {#build-defi} + +التمويل اللامركزي هو حركة مفتوحة المصدر. بروتوكولات التمويل اللامركزي وتطبيقاته كلها مفتوحة للفحص، والتفكير، والإبداع. بسبب هذا التركيب المتراكب كطبقات (تشترك جميعها في نفس سلسلة الكتل والأصول الأساسية)، يمكن مزج البروتوكولات ومطابقتها لفتح فرص كثيرة فريدة. + + + المزيد حول بناء التطبيقات اللامركزية + + +## قراءة إضافية {#futher-reading} + +### بيانات التمويل اللامركزي {#defi-data} + +- [DeFi Prime](https://defiprime.com/) +- [DeFi Llama](https://defillama.com/) +- [DeFi Rate](https://defirate.com/) + +### مقالات التمويل اللامركزي {#defi-articles} + +- [A beginner's guide to DeFi](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _Sid Coelho-Prabhu, January 6 2020_ - (دليل المبتدئين لتعلم التمويل اللامركزي) + +### مقاطع الفيديو {#videos} + +- [Finematics - decentralized finance education](https://finematics.com/) – _Videos on DeFi_ - تعليم التمويل اللامركزي +- [المؤجل](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _أساسيات ديفي: كل شيء تحتاج إلى معرفته للبدء به في هذه المساحة المحفزة أحياناً_ +- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) _What is DeFi?_ - ماهو التمويل اللامركزي + +### المجتمعات {#communities} + +- [خادم DeFi Llama Discord](https://discord.gg/buPFYXzDDd) +- [خادم DeFi Pulse Discord](https://discord.gg/Gx4TCTk) diff --git a/src/content/translations/ar/desci/index.md b/src/content/translations/ar/desci/index.md new file mode 100644 index 00000000000..eeccfbfe630 --- /dev/null +++ b/src/content/translations/ar/desci/index.md @@ -0,0 +1,138 @@ +--- +title: لا مركزية العلوم (DeSci) +description: نظرة عامة على العلوم اللامركزية على إثيريوم +lang: ar +template: use-cases +emoji: ":microscope:" +sidebarDepth: 2 +image: ../../../../assets/future_transparent.png +alt: "" +summaryPoint1: نظام عالمي ومفتوح بديل للنظام العلمي الحالي. +summaryPoint2: تتيح التكنولوجيا للعلماء جمع التمويل وإجراء التجارب، ومشاركة البيانات، ونشر النتائج، والمزيد. +summaryPoint3: يعتمد على حركة العلوم المفتوحة. +--- + +## ما المقصود بالعلوم اللامركزية (DeSci)؟ {#what-is-desci} + +العلوم اللامركزية (DeSci) هي حركة تهدف إلى بناء بنية تحتية عامة لتمويل، وإنشاء، ومراجعة، واعتماد، وتخزين، ونشر المعرفة العلمية بشكل منصف وعادل باستخدام حزمة Web3. + +تهدف العلوم اللامركزية إلى خلق بيئة تشجع العلماء على مشاركة أبحاثهم بشكل مفتوح والحصول على الاعتماد لعملهم في حين يسمح لأي شخص بالوصول إلى الأبحاث والمساهمة فيها بسهولة. تعمل العلوم اللامركزية على فكرة أن المعرفة العلمية يجب أن تكون متاحة للجميع وأن عملية البحث العلمي يجب أن تكون شفافة. تقوم العلوم اللامركزية بخلق نموذج للبحث العلمي أكثر وتوزيعا وعدم مركزية، مما يجعله أكثر مقاومة للرقابة والتحكم من جانب السلطات المركزية. تأمل العلوم اللامركزية في خلق بيئة حيث يمكن للأفكار الجديدة وغير التقليدية أن تزدهر من خلال عدم مركزية الوصول إلى التمويل، والأدوات العلمية، وقنوات الاتصال. + +تسمح العلوم اللامركزية بمصادر تمويل أكثر تنوعًا (من [DAOs](/dao/)، [التبرعات الرباعية](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531) إلى التمويل الجماعي والمزيد)، وتوفر وصولًا أسهل إلى البيانات والطرق، وعن طريق توفير حوافز لإعادة التكرار. + +### جوان بينيت - حركة العلوم اللامركزية + + + +## كيف تحسن العلوم اللامركزية من العلوم {#desci-improves-science} + +قائمة غير كاملة للمشكلات الرئيسية في العلوم وكيف يمكن للعلوم المركزية المساعدة في معالجة هذه المشكلات + +| **العلوم اللامركزية** | **العلوم التقليدية** | +| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | +| يُحدد توزيع الأموال بواسطة الجمهور باستخدام آليات مثل التبرعات الرباعية أو DAOs. | تقوم مجموعات صغيرة ومغلقة ومركزية بالتحكم في توزيع الأموال. | +| أنت تتعاون مع زملائك من جميع أنحاء العالم في فرق ديناميكية. | تقوم منظمات التمويل والمؤسسات الوطنية بتقييد عمليات التعاون. | +| القرارات المتعلقة بالتمويل تتم على الإنترنت وبشفافية. تم استكشاف آليات تمويل جديدة. | يتم اتخاذ القرارات بعد وقت طويل وبشكل محدود في الشفافية. يتواجد القليل من آليات التمويل. | +| تصبح مشاركة خدمات المختبرات أسهل وأكثر شفافية باستخدام المبادئ الأساسية لـ Web3. | تتم مشاركة موارد المختبر بطريقة بطيئة وغير شفافة في كثير من الأحيان. | +| يمكن تطوير نماذج جديدة للنشر تستخدم المبادئ الأساسية لـ Web3 للثقة، والشفافية، والوصول العالمي. | أنت تنشر من خلال مسارات معتمدة يتم الإقرار كثيرا بأنها غير فعالة ومتحيزة ومستغلة. | +| يمكنك كسب رموز مميزة وسمعة عند مراجعة أعمال النظراء. | عملك في مراجعة النظراء غير مدفوع، مما ينتفع به ناشرون يسعون للربح. | +| أنت تملك الملكية الفكرية (IP) التي تنتجها وتوزعها وفقًا لشروط شفافة. | مؤسستك الوطنية تمتلك الملكية الفكرية (IP) التي تنتجها. الوصول إلى الملكية الفكرية IP ليس شفافًا. | +| مشاركة جميع أبحاثك، بما في ذلك بيانات الجهود غير ناجحة، عن طريق وضع جميع الخطوات على السلسلة. | تعني التحيز في النشر أن الباحثين أكثر عرضة لمشاركة التجارب التي حققت نتائج ناجحة. | + +## إثيريوم والعلوم اللامركزية {#ethereum-and-desci} + +سيحتاج نظام العلوم اللامركزي إلى أمان قوي، وتكاليف مادية ومعاملات أدنى، ونظام بيئي غني لتطوير التطبيقات. يوفر إثيريوم كل ما يلزم لبناء حزمة أدوات العلوم اللامركزية. + +## حالات استخدام العلوم اللامركزية {#use-cases} + +تبني العلوم اللامركزية مجموعة أدوات علمية لإدخال أكاديميات Web3 إلى العالم الرقمي. فيما يلي عينات من حالات الاستخدام التي يمكن توفيرها من خلال Web3 للمجتمع العلمي. + +### النشر {#publishing} + +نشر العلوم يعد مشكلة معروفة نظرًا لأنه يتم إدارته من جانب دور النشر التي تعتمد على العمل المجاني من العلماء، والمراجعين، والمحررين، لإنتاج الأوراق العلمية ولكنها تفرض رسوم نشر باهظة. الجمهور، الذي يدفع عادة بشكل غير مباشر للعمل وتكاليف النشر من خلال الضرائب، لا يستطيع عادة الوصول إلى نفس العمل دون الدفع للناشر مرة أخرى. تكون الرسوم الكلية لنشر أوراق العلوم الفردية في كثير من الأحيان بين خمسة أرقام ($USD)، مما يقوض مفهوم المعرفة العلمية [كصالح عام](https://www.econlib.org/library/Enc/PublicGoods.html) بينما يولد أرباحًا هائلة لمجموعة صغيرة من الناشرين. + +توجد منصات حرة ومفتوحة الوصول على شكل خوادم مسودات المقالات العلمية، [مثل ArXiv](https://arxiv.org/). ومع ذلك، تفتقر هذه المنصات إلى مراقبة الجودة، و[آليات مكافحة sybil](https://csrc.nist.gov/glossary/term/sybil_attack)، ولا تتعقب بشكل عام المقاييس على مستوى المقالة، مما يعني أنها تستخدم عادةً فقط للإعلان عن العمل قبل تقديمه إلى ناشر تقليدي. يجعل SciHub أيضًا الأوراق المنشورة مجانية الوصول إليها، ولكن ليس بشكل قانوني، وفقط بعد أن يكون الناشرون قد أخذوا بالفعل مدفوعاتهم وأحاطوا العمل بتشريع صارم لحقوق النشر. يترك هذا فجوة حرجة للأوراق العلمية والبيانات التي يمكن الوصول إليها مع آلية شرعية مضمنة ونموذج حافز. أدوات بناء مثل هذا النظام موجودة في Web3. + +### قابلية إعادة الإنتاج والتكرار {#reproducibility-and-replicability} + +القابلية لإعادة الإنتاج والتكرار هي أسس الاكتشاف العلمي الجيد. + +- يمكن تحقيق نتائج قابلة لإعادة الإنتاج عدة مرات متتالية بواسطة نفس الفريق باستخدام نفس المنهجية. +- يمكن تحقيق نتائج قابلة للتكرار بواسطة مجموعة مختلفة باستخدام نفس الإعداد التجريبي. + +يمكن لأدوات Web3 الأصلية أن تضمن أن إعادة الإنتاج والتكرار هما أساس الاكتشاف. يمكننا دمج علم الجودة في النسيج التكنولوجي للأوساط الأكاديمية. يوفر Web3 القدرة على إنشاء مصادقات لكل مكون من مكونات التحليل: البيانات الأولية، والمحرك الحسابي، ونتائج التطبيق. يكمن جمال أنظمة إجماع الآراء في أنه عند إنشاء شبكة موثوقة للحفاظ على هذه المكونات، يمكن أن يكون كل مشارك في الشبكة مسؤولاً عن إعادة إنتاج الحساب والتحقق من صحة كل نتيجة. + +### التمويل {#funding} + +النموذج القياسي الحالي لتمويل العلوم هو أن الأفراد أو مجموعات العلماء يقدمون طلبات مكتوبة إلى وكالة التمويل. تقوم لجنة صغيرة من الأفراد الموثوق بهم بتقييم الطلبات ثم إجراء مقابلات مع المرشحين قبل منح الأموال لجزء صغير من المتقدمين. بصرف النظر عن خلق الاختناقات التي تؤدي في بعض الأحيان إلى سنوات من الانتظار بين التقدم للحصول على منحة وتلقيها، من المعروف أن هذا النموذج معرض بشكل كبير للتحيزات والمصالح الذاتية وسياسات لجنة المراجعة. + +أظهرت الدراسات أن لجان مراجعة المنح تقوم بعمل ضعيف في اختيار المقترحات عالية الجودة، لأن المقترحات نفسها المقدمة إلى اللجان المختلفة لها نتائج مختلفة تمامًا. نظرًا لأن التمويل أصبح أكثر ندرة، فقد تركز على مجموعة أصغر من كبار الباحثين الذين لديهم مشاريع أكثر تحفظًا من الناحية الفكرية. وقد أدى التأثير إلى خلق مشهد تمويل شديد التنافسية، مما أدى إلى ترسيخ الحوافز الضارة وخنق الابتكار. + +Web3 لديه القدرة على تعطيل نموذج التمويل المعطل هذا من خلال تجربة نماذج الحوافز المختلفة التي طورتها DAOs وWeb3 على نطاق واسع. [تمويل السلع العامة بأثر رجعي](https://medium.com/ethereum-optimism/retroactive-public-goods-funding-33c9b7d00f0c)، [التمويل الرباعي](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531)، [حوكمة DAO](https://www.antler.co/blog/daos-and-web3-governance) و[هياكل الحوافز الرمزية](https://cdixon.org/2017/05/27/crypto-tokens-a-breakthrough-in-open-network-design) هي بعض أدوات Web3 التي يمكن أن تحدث ثورة في تمويل العلوم. + +### ملكية الملكية الفكرية وتطويرها {#ip-ownership} + +تُعد الملكية الفكرية (IP) مشكلة كبيرة في العلوم التقليدية: من الركود في الجامعات أو عدم استخدامها في مجال التكنولوجيا الحيوية، إلى صعوبة تقدير قيمتها. ومع ذلك، فإن ملكية الأصول الرقمية (مثل البيانات أو المقالات العلمية) هي شيء تقوم به Web3 بشكل جيد للغاية باستخدام [رموز غير قابلة للاستبدال (NFTs)](/nft/). + +بالطريقة نفسها التي يمكن بها لـ NFTs تمرير إيرادات المعاملات المستقبلية إلى المنشئ الأصلي، يمكنك إنشاء سلاسل إحالة قيمة شفافة لمكافأة الباحثين أو الهيئات الحاكمة (مثل DAOs) أو حتى الأشخاص الذين يتم جمع بياناتهم. + +يمكن أيضًا أن يعمل [IP-NFTs](https://medium.com/molecule-blog/ip-nfts-for-researchers-a-new-biomedical-funding-paradigm-91312d8d92e6) كمفتاح لمستودع بيانات لامركزي للتجارب البحثية التي يتم إجراؤها، وإدخاله في NFT و [DeFi](/defi/) توظيف المدخرات (من التجزئة إلى تجمعات الإقراض وتقييم القيمة). كما أنه يسمح للكيانات الموجودة في السلسلة مثل DAOs مثل [VitaDAO](https://www.vitadao.com/) بإجراء بحث مباشر على السلسلة. قد يلعب ظهور الرموز [غير القابلة للتحويل "الثابتة"](https://vitalik.ca/general/2022/01/26/soulbound.html) أيضًا دورًا مهمًا في العلوم اللامركزية من خلال السماح للأفراد بإثبات خبرتهم وبيانات اعتمادهم المرتبطة بعنوان إثيريوم الخاص بهم. + +### تخزين البيانات والوصول إليها والهندسة المعمارية {#data-storage} + +يمكن جعل البيانات العلمية أكثر سهولة في الوصول إليها باستخدام أنماط Web3، كما أن التخزين الموزع يمكّن البحث من النجاة من الأحداث الكارثية. + +يجب أن تكون نقطة البداية نظامًا يمكن الوصول إليه بواسطة أية هوية لامركزية تحمل بيانات الاعتماد المناسبة التي يمكن التحقق منها. يتيح ذلك نسخ البيانات الحساسة بشكل آمن بواسطة الأطراف الموثوقة، مما يتيح مقاومة التكرار والرقابة، وإعادة إنتاج النتائج، وحتى قدرة أطراف متعددة على التعاون وإضافة بيانات جديدة إلى مجموعة البيانات. إن طرق الحوسبة السرية مثل [الحوسبة على البيانات](https://7wdata.be/predictive-analytics/compute-to-data-using-blockchain-to-decentralize-data-science-and-ai-with-the-ocean-protocol) توفر آليات وصول بديلة لتكرار البيانات الخام، مما يؤدي إلى إنشاء بيئات بحث موثوق بها للبيانات الأكثر حساسية. إن بيئات البحث الموثوقة [تم الاستشهاد بها بواسطة](https://medium.com/weavechain/whats-in-store-for-the-future-of-healthcare-data-b6398745fbbb) كحل يواجه المستقبل لخصوصية البيانات والتعاون من خلال إنشاء نظام بيئي حيث يمكن للباحثين العمل بأمان مع البيانات في الموقع باستخدام بيئات موحدة لمشاركة النص البرمجي والممارسات. + +تدعم حلول بيانات Web3 المرنة السيناريوهات المذكورة أعلاه وتوفر الأساس للعلم المفتوح حقًا، حيث يمكن للباحثين إنشاء سلع عامة دون أذونات الوصول أو الرسوم. تم تحسين حلول البيانات العامة لـ Web3 مثل IPFS وArweave وFilecoin لتحقيق اللامركزية. dClimate، على سبيل المثال، يوفر وصولاً شاملاً إلى بيانات المناخ والطقس، بما في ذلك من محطات الطقس، والنماذج المناخية التنبؤية. + +## شارك {#get-involved} + +استكشف المشاريع وانضم إلى مجتمع العلوم اللامركزية. + +- [DeSci.Global: الأحداث العالمية وتقويم اللقاءات](https://desci.global) +- [سلسلة الكتل Science Telegram](https://t.me/BlockchainForScience) +- [Molecule: موّل واحصل على تمويل لمشاريعك البحثية](https://discover.molecule.to/) +- [VitaDAO: تلقي التمويل من خلال اتفاقيات البحث المدعومة للأبحاث طويلة العمر](https://www.vitadao.com/) +- [ResearchHub: انشر نتيجة علمية وانخرط في محادثة مع نظرائك](https://www.researchhub.com/) +- [LabDAO: إدماج البروتين في الحاسوب](https://alphafodl.vercel.app/) +- [dClimate API: الاستعلام عن البيانات المناخية التي تم جمعها من قبل مجتمع لامركزي](https://api.dclimate.net/) +- [DeSci Foundation: منشئ أداة نشر العلوم اللامركزية](https://descifoundation.org/) +- [DeSci.World: متجر شامل يتيح للمستخدمين عرض العلوم اللامركزية والتفاعل معها](https://desci.world) +- [Fleming Protocol: اقتصاد بيانات مفتوحة المصدر يغذي اكتشاف الطب الحيوي التعاوني](https://medium.com/@FlemingProtocol/a-data-economy-for-patient-driven-biomedical-innovation-9d56bf63d3dd) +- [OceanDAO: DAO يحكم التمويل للعلوم المتعلقة بالبيانات](https://oceanprotocol.com/dao) +- [Opscientia: فتح تدفقات عمل العلوم اللامركزية](https://opsci.io/research/) +- [LabDAO: إدماج البروتين في الحاسوب](https://alphafodl.vercel.app/) +- [Bio.xyz: احصل على تمويل لمشروع DAO للتكنولوجيا الحيوية، أو مشروع العلوم اللامركزية الخاص بك](https://www.molecule.to/) +- [ResearchHub: انشر نتيجة علمية وانخرط في محادثة مع نظرائك](https://www.researchhub.com/) +- [VitaDAO: تلقي التمويل من خلال اتفاقيات البحث المدعومة للأبحاث طويلة العمر](https://www.vitadao.com/) +- [Fleming Protocol: اقتصاد بيانات مفتوحة المصدر يغذي اكتشاف الطب الحيوي التعاوني](https://medium.com/@FlemingProtocol/a-data-economy-for-patient-driven-biomedical-innovation-9d56bf63d3dd) +- [معمل الاستدلال النشط](https://www.activeinference.org/) +- [CureDAO: منصة الصحة الدقيقة المملوكة للمجتمع](https://docs.curedao.org/) +- [IdeaMarkets: تمكين المصداقية العلمية اللامركزية](https://ideamarket.io/) + +نحن نرحب بقائمة من اقتراحات المشاريع الجديدة - يرجى إلقاء نظرة على [سياسة القائمة](/contributing/adding-desci-projects/) للبدء! + +## قراءة إضافية {#further-reading} + +- [DeSci Wiki بواسطة جوسلين بيرل وألترارير](https://docs.google.com/document/d/1aQC6zn-eXflSmpts0XGE7CawbUEHwnL6o-OFXO52PTc/edit#) +- [دليل للتكنولوجيا الحيوية اللامركزية بقلم جوسلين بيرل لمستقبل a16z](https://future.a16z.com/a-guide-to-decentralized-biotech/) +- [حالة العلوم اللامركزية](https://gitcoin.co/blog/desci-the-case-for-decentralised-science/) +- [دليل إلى العلوم اللامركزية](https://future.com/what-is-decentralized-science-aka-desci/) +- [موارد العلوم اللامركزية](https://www.vincentweisser.com/decentralized-science) +- [Molecule's Biopharma IP-NFTs - وصف تقني](https://molecule.to/blog/molecules-biopharma-ip-nfts-a-technical-description) +- [بناء أنظمة علمية غير موثوقة بقلم جون ستار](https://medium.com/@jringo/building-systems-of-trustless-science-1cd2d072f673) +- [ظهور DAOs للتكنولوجيا الحيوية](https://molecule.to/blog/the-emergence-of-biotech-daos) +- [بول كولهاس - DeSci: The Future of Decentralized Science (بودكاست)](https://anchor.fm/andrew-steinwold/episodes/Paul-Kohlhaas---DeSci-The-Future-of-Decentralized-Science---Zima-Red-ep-117-e1h683a) +- [أنطولوجيا الاستدلال النشط للعلوم اللامركزية: من صنع الحواس إلى المشاع المعرفي](https://zenodo.org/record/6320575) +- [العلوم اللامركزية: مستقبل البحث بواسطة صامويل أكينوشو](https://lucidsamuel.medium.com/desci-the-future-of-research-b76cfc88c8ec) +- [التمويل العلمي (الخاتمة: العلوم الامركزية وأوليات التشفير الجديدة) بواسطة ناديا](https://nadia.xyz/science-funding) +- [اللامركزية تعطل تطوير الأدوية](https://medium.com/id-theory/decentralisation-is-disrupting-drug-development-28b5ba5d447f) + +### مقاطع الفيديو {#videos} + +- [ما هي العلوم اللامركزية؟](https://www.youtube.com/watch?v=-DeMklVWNdA) +- [محادثة بين فيتاليك بوتيرين والعالم أوبري دي جراي حول تقاطع الأبحاث طويلة العمر والتشفير](https://www.youtube.com/watch?v=x9TSJK1widA) +- [النشر العلمي معطل. هل يستطيع Web3 إصلاح ذلك؟](https://www.youtube.com/watch?v=WkvzYgCvWj8) +- [خوان بينيت - العلوم اللامركزية، المختبرات المستقلة وعلم البيانات واسعة النطاق](https://www.youtube.com/watch?v=zkXM9H90g_E) +- [سيباستيان برونماير - كيف يمكن للعلوم اللامركزية تحويل الأبحاث الطبية الحيوية ورأس المال الاستثماري](https://www.youtube.com/watch?v=qB4Tc3FcVbM) diff --git a/src/content/translations/ar/smart-contracts/index.md b/src/content/translations/ar/smart-contracts/index.md new file mode 100644 index 00000000000..e587d7a834d --- /dev/null +++ b/src/content/translations/ar/smart-contracts/index.md @@ -0,0 +1,94 @@ +--- +title: العقود الذكية +description: مقدمة غير تقنية للعقود الذكية +lang: ar +--- + +# مدخل إلى العقود الذكية {#introduction-to-smart-contracts} + +العقود الذكية هي لبنات البناء الأساسية [لتطبيقات إثيريوم](/dapps/). وهي برامج حاسوبية مخزنة على سلسلة الكتل تسمح بتحويل العقود التقليدية إلى عقود رقمية موازية. تتبع العقود الذكية المنطق بصرامة - وتتبع هيكلية 'إذا تحقق هذا الشرط، إذن افعل هذه العملية'. وبالتالي فإنها تعمل بالضبط وفقًا للمنطق البرمجي التي بُنيت عليه و لا يمكن تعديلها. + +وقد صاغ نيك سزابو مصطلح "العقد الذكي". حيث كتب في عام 1994، [مقدمة للمفهوم](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart.contracts.html) ثم كتب في عام 1996 [استكشاف لما يمكن أن تفعله العقود الذكية](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart_contracts_2.html). + +لقد تصور نيك سزابو سوقًا رقميًا مبنيًا على هذه العمليات التلقائية والآمنة والمشفرة. كحيز يمكن أن تتم فيه المعاملات المالية والأعمال التجارية بغنى عن الوسطاء و دون الاعتماد على الثقة بين الأطراف. جاءت اليوم عقود إثيريوم الذكية لتجعل هذه الفكرة قابلة للتطبيق. + +## ما هي العقود؟ {#what-are-contracts} + +ربما تراودك فكرة: _"أنا لست محامياً! فما المبرر حتى أهتم بالعقود؟"_. ينظر معظم الناس للعقود على أنها مجرد شروط واتفاقيات أو وثائق قانونية طويلة لا داعي لها. + +العقود هي مجرد اتفاقيات. أي أنه يمكن تضمين أي شكل من الاتفاقيات في شروط العقد. تلقى الاتفاقيات الشفوية أو العقود الورقية قبولًا في عدة أمور، ولكنها لا تخلو من العيوب. + +### الثقة والعقود {#trust-and-contracts} + +إحدى أهم المشاكل في العقود التقليدية هي الحاجة لوجود أشخاص موثوق بهم لمتابعة نتائج العقد. + +مثالا على ذلك: + +أليس وبوب لديهما سباق دراجات. فلنفترض أن أليس راهنت بوب على 10 دولارات أنها ستفوز عليه في السباق. ولأن بوب واثق من قدرته على الفوز في السباق، وافق على الرهان. في النهاية، سبقت أليس بوب بفارق كبير وكانت هي الرابحة دون أدنى شك. لكن بوب رفض دفع الرهان مدعيًا أنه بالتأكيد أليس قد غشت. + +هذا مثال بسيط يوضح المشكلة المتعلقة بأي اتفاقية غير ذكية. وحتى لو استوفيت شروط الاتفاق (أي أنت الفائز في السباق)، فلابد أن تضع ثقتك بشخص آخر يفي بالاتفاقية (أي الدفع في الرهان). + +## العقود الذكية {#smart-contracts} + +العقود الذكية تجعل الاتفاقيات رقمية عن طريق تحويل شروط الاتفاقية إلى نص برمجي يُنفذ تلقائيًا عند تحقق شروط العقد. + +### آلة بيع رقمية {#vending-machine} + +أبسط تشبيه مجازي لعقد ذكي هو آلة بيع تعمل بشكل مماثل إلى حد ما للعقد الذكي - مدخلات محددة تضمن نتائج محددة. + +- أنت تختار المنتج +- آلة البيع تظهر ثمن شراء المنتج المطلوب +- أنت تدخل المبلغ الصحيح +- آلة البيع تتحقق من أنك أدخلت المبلغ الصحيح +- آلة البيع تخرج المنتج المختار + +لن تخرج آلة البيع سوى المنتج المرغوب فقط عند استيفاء جميع الشروط. ففي حال لم تحدد المنتج أو تُدخل ما يكفي من المال، فإن آلة البيع لن تعطيك المنتج الذي ترغب به. + +### التنفيذ التلقائي {#automation} + +واحدة من أهم الفوائد التي تتمتع بها العقود الذكية مقارنةً بالعقود العادية هي أن الالتزامات تنفذ تلقائياً عندما تتحقق شروط العقد. ليس هناك حاجة لانتظار تنفيذ النتيجة بواسطة أي شخص. بعبارة أخرى: العقود الذكية تزيل الحاجة إلى الوثوق بالأشخاص. + +مثلًا، يمكن كتابة عقد ذكي للاحتفاظ بمبلغ من المال في صندوق ضمان للطفل، و لا يسمح له بسحب الأموال إلا بعد تاريخ محدد. فلو حاول سحب الأموال قبل التاريخ المحدد في العقد، فإن العقد الذكي لن يسمح بتنفيذ عملية السحب. أو يمكنك كتابة عقد يعطيك تلقائيًا نسخة رقمية من حيازة السيارة عندما تدفع ثمنها للتاجر. + +### النتائج المتوقعة {#predictability} + +العامل البشري هو أحد أكبر نِقَاط الضعف في العقود التقليدية. فمثلًا، قد يفسر قاضيان مستقلان عقدًا تقليديًا بطريقتين مُختلفتين. وبالتالي سيؤدي اختلاف تفسيراتهما إلى اتخاذ قرارات مختلفة وإلى نتائج متباينة. بينما تزيل العقود الذكية إمكانية حصول تفسيرات مختلفة. وبدلاً من ذلك، تنفذ العقود الذكية الالتزامات بدقة استناداً إلى الشروط المكتوبة ضمن النص البرمجي للعقد. وتعني هذه الدقة أنه بالنظر إلى نفس الظروف، فإن العقد الذكي سيسفر عن النتيجة نفسها. + +### السجل العام {#public-record} + +تُفيد العقود الذكية أيضا في المراجعة والتتبع. نظرًا لأن العقود الذكية في إثيريوم موجودة ضمن سلسلة كتل عامة، يمكن لأي شخص أن يتتبع على الفور عمليات نقل الأصول والمعلومات الأخرى المتعلقة بها. فمثلًا، يمكنك التحقق لترى ما إذا كان شخص ما قد أرسل أموالاً إلى عنوانك. + +### حماية الخصوصية {#privacy-protection} + +يُمكن للعقود الذكية أيضا حماية خصوصيتك. بما أن إثيريوم شبكة مستترة (يتاح للعموم عنوان تشفير فريد مرتبط بمعاملاتك وليس هويتك الشخصية)، يمكنك حماية خصوصيتك من المتتبعين. + +### الشروط مرئية {#visible-terms} + +أخيرا، كما في العقود التقليدية، يمكنك التحقق من محتوى العقد الذكي قبل أن توقعه (أو أن تتفاعل معه). إلا أن الأمر الأفضل هو أن الشفافية العلنية للشروط الواردة في العقد تعني أنه بإمكان أي شخص أن يدقق تلك الشروط. + +## حالات استخدام العقود الذكية {#use-cases} + +إذن فإن العقود الذكية هي برامج حاسوبية تعمل ضمن سلسلة الكتل. ويمكن أن تُنفذ التعليمات الواردة فيها تلقائيًا. كما يمكنك تتبع معاملات العقد، وتوقع سلوكه وحتى استخدامه دون الكشف عن هويتك. هذا رائع. ولكن ما فائدتها؟ حسنًا، العقود الذكية يمكن أن تؤدي في الأساس أي شيء تفعله برامج الكمبيوتر الأخرى. + +يمكنها انجاز الحسابات، وإنشاء عملات، وتخزين البيانات، وتخزين NFT، وإرسال المراسلات، أو حتى إنشاء مخططات. وفيما يلي بعض الأمثلة الواقعية الشائعة: + +- [عملات ثابتة](/stablecoins/) +- [إنشاء أصول رقمية فريدة وتوزيعها](/nft/) +- [بورصة تداول عملات مفتوحة وتلقائية](/get-eth/#dex) +- [ألعاب الفيديو اللامركزية](/dapps/?category=gaming) +- [بوليصة التأمين يتم دفعها تلقائيًا](https://etherisc.com/) +- [معيار قياسي يتيح للأشخاص إنشاء عملات مخصصة وقابلة للتشغيل المتبادل](/developers/docs/standards/tokens/) + +## أتريد المزيد من المعلومات المرئية؟ {#visual-learner} + +شاهد فيديو لـ Finematics تشرح به العقود الذكية: + + + +## قراءة إضافية {#further-reading} + +- [How Smart Contracts Will Change the World - (كيف ستغير العقود الذكية العالم)](https://www.youtube.com/watch?v=pA6CGuXEKtQ) +- [Smart Contracts: The Blockchain Technology That Will Replace Lawyers - (العقود الذكية: تقنية سلاسل الكتل التي ستحل محل المحامين)](https://blockgeeks.com/guides/smart-contracts/) +- [Smart contracts for developers - (العقود الذكية للمبرمجين)](/developers/docs/smart-contracts/) +- [Learn to write smart-contracts - (تعلم كتابة العقود الذكية)](/developers/learning-tools/) +- [Mastering Ethereum - What is a Smart Contract (إتقان إثيريوم - ما هو العقد الذكي؟)](https://github.com/ethereumbook/ethereumbook/blob/develop/07smart-contracts-solidity.asciidoc#what-is-a-smart-contract) diff --git a/src/content/translations/ar/social-networks/index.md b/src/content/translations/ar/social-networks/index.md new file mode 100644 index 00000000000..830a076fdb8 --- /dev/null +++ b/src/content/translations/ar/social-networks/index.md @@ -0,0 +1,119 @@ +--- +title: الشبكات الاجتماعية اللامركزية +description: نظرة عامة على الشبكات الاجتماعية اللامركزية على إثيريوم +lang: ar +template: use-cases +emoji: ":mega:" +sidebarDepth: 2 +image: ../../../../assets/ethereum-learn.png +summaryPoint1: منصات قائمة على سلسلة الكتل للتفاعل الاجتماعي وإنشاء المحتوى وتوزيعه. +summaryPoint2: إن شبكات التواصل الاجتماعي اللامركزية تحمي خصوصية المستخدمين وتعزز أمن البيانات. +summaryPoint3: الرموز المميزة و NFTs تنشئ أساليب جديدة لتحويل المحتوى إلى أموال. +--- + +تلعب الشبكات الاجتماعية دورًا محوريًا في تواصلنا وتفاعلاتنا اليومية. غير أن التحكم المركزي بهذه المنصات يسبب مشاكل كثيرة منها: خرق البيانات، وتوقف الخوادم، وإلغاء المنصات، والرقابة، وانتهاكات الخصوصية نتيجة بعض المقايضات التي تجريها منصات التواصل الاجتماعي أحيانًا. لمواجهة هذه القضايا، يقوم المبرمجون ببناء شبكات اجتماعية على إثيريوم. يمكن للشبكات الاجتماعية اللامركزية أن تصلح العديد من مشاكل منصات التواصل الاجتماعي التقليدية، و تحسن تجرِبة المستخدم العامة. + +## ما هي الشبكات الاجتماعية اللامركزية؟ {#what-are-decentralized-social-networks} + +الشبكات الاجتماعية اللامركزية هي منصات قائمة على سلسلة الكتل، تسمح للمستخدمين بتبادل المعلومات فضلًا عن نشر المحتوى وتوزيعه على الجمهور. نظرًا لأن هذه التطبيقات تعمل على سلسلة الكتل، فهي قادرة على أن تكون لامركزية ومقاومة للرقابة والتحكم المفرط. + +توجد العديد من الشبكات الاجتماعية اللامركزية كبدائل لخدمات وسائل التواصل الاجتماعي الموجودة، مثل Facebook، وLinkedIn، وTwitter، وMedium. ولكن لدى الشبكات الاجتماعية القائمة على سلسلة الكتل مجموعة من السمات تُميزها عن المنصات الاجتماعية التقليدية. + +### كيف تعمل شبكات التواصل الاجتماعية اللامركزية؟ {#decentralized-social-networks-overview} + +الشبكات الاجتماعية اللامركزية هي فئة من [التطبيقات اللامركزية](/dapps/)-أي التطبيقات المدعومة [بالعقود الذكية](/developers/docs/smart-contracts/) المنشورة على سلسلة الكتل. يعمل النص البرمجي للعقد الذكي كواجهة خلفية لهذه التطبيقات ويحدد منطق أعمالها. + +تعتمد منصات التواصل الاجتماعي التقليدية على قواعد البيانات لتخزين معلومات المستخدم، والنص البرمجي، وأشكال أخرى من البيانات. ولكن هذا يؤدي لنقطة ضعف ويسبب مخاطر كبيرة. على سبيل المثال، خوادم Fecabook السخيفة [انفصلت لعدة ساعات](https://www.npr.org/2021/10/05/1043211171/facebook-instagram-whatsapp-outage-business-impact) في العام الماضي، فقطعت المستخدمين عن المنصة. + +توجد شبكات اجتماعية لامركزية على شبكة من النظراء تتألف من آلاف العُقد حول العالم. حتى لو توقفت بعض العقد، فإن الشبكة ستعمل دون انقطاع، مما يجعل التطبيقات مقاومة للفشل أو انقطاع الاتصال. + +باستخدام نظم تخزين لامركزية مثل [نظام الملفات InterPlanetary](https://ipfs.io/)، فإن الشبكات الاجتماعية المبنية على إثيريوم يمكن أن تحمي معلومات المستخدم من الاستغلال والاستخدام الخبيث. لن يتمكن أحد من بيع معلوماتك الشخصية إلى المعلنين، ولن يتمكن القراصنة من سرقة بياناتك الخاصة. + +العديد من المنصات الاجتماعية القائمة على سلسلة الكتل لديها رموز مميزة اصلية تعمل على تحويل المحتوى إلى نقود في غياب إيرادات الترويج. يمكن للمستخدمين شراء هذه الرموز المميزة للوصول إلى ميزات محددة، أو إكمال عمليات الشراء داخل التطبيق، أو مكافأة منشئي المحتوى المفضلين لديهم. + +## فوائد الشبكات الاجتماعية اللامركزية {#benefits} + +1. الشبكات الاجتماعية اللامركزية مقاومة للرقابة ومفتوحة للجميع. وبالتالي لا يمكن حظر المستخدمين، أو إزالتهم، أو تقييدهم لسبب تعسفي. + +2. تبنى الشبكات الاجتماعية اللامركزية على القيم والمُثل مفتوحة المصدر، وتتيح للعموم الاطلاع والتحقق من النص البرمجي للمصدر. ويمكن للشبكات الاجتماعية القائمة على سلاسل الكتل مواءمة مصالح المستخدمين ومبتكري المنصات الاجتماعية، عن طريق إلغاء تنفيذ الخوارزميات المبهمة الشائعة في وسائل التواصل الاجتماعي التقليدية. + +3. تلغي الشبكات الاجتماعية اللامركزية دور "الوسيط". منشئو المحتوى لديهم ملكية مباشرة لمحتوياتهم، ويشاركون مباشرة مع المتابِعين، والمشجعين، والمشترين، والأطراف الأخرى، وليس بينهم سوى عقد ذكي. + +4. كما هو الحال مع التطبيقات اللامركزية التي تعمل على شبكة إثيريوم، التي تدعمها شبكة عُقد عالمية بين النظراء، فإن الشبكات الاجتماعية اللامركزية هي أقل عرضة لتوقف عمل الخادم وانقطاع الخدمة. + +5. توفر المنصات الاجتماعية اللامركزية لمنشئي المحتوى إطارًا محسنًا لتحويل المحتوى إلى نقود عن طريق الرموز غير القابلة للاستبدال (NFT)، والمدفوعات المشفرة في التطبيقات، وغيرها. + +6. توفر الشبكات الاجتماعية اللامركزية للمستخدمين مستوىً عالٍ من الخصوصية وإخفاء الهوية. فمثلًا، يمكن لأي أحد أن يسجل دخوله إلى شبكة اجتماعية قائمة على إثيريوم باستخدام ملف تعريف ENS (عنوان خادم إثيريوم) أو محفظة إثيريوم، دون أن يضطر إلى مشاركة معلومات معرفة للشخصية، مثل الأسماء، أو عناوين البريد الإلكتروني، إلخ. + +7. تعتمد الشبكات الاجتماعية اللامركزية على التخزين اللامركزي، وليس على قواعد بيانات مركزية، وهي تُعد أفضل بكثير لحماية بيانات المستخدم. + +## الشبكات الاجتماعية اللامركزية على إثيريوم {#ethereum-social-networks} + +أصبحت شبكة إثيريوم الأداة المفضلة للمبرمجين لإنشاء وسائل تواصل إجتماعي لامركزية بسبب شعبية رموزها المميزة (ERC-20/ERC-721) وقاعدة مستخدميها الضخمة. وفيما يلي بعض الأمثلة على الشبكات الاجتماعية القائمة على إثيريوم: + +### Peepeth {#peepeth} + +[Peepeth](https://peepeth.com/) وهي منصة شبيهة بـ Twitter مخصصة للتدوينات القصيرة. تعمل على سلسلة كتل إثيريوم وتستخدم IPFS لتخزين بيانات المستخدم. + +يمكن للمستخدمين إرسال رسائل قصيرة تسمى "Peeps"، لا يمكن حذفها أو تعديلها. يمكنك جمع المال أو تقديمه لأي شخص على المنصة بعملة الإثير (ETH) دون ترك التطبيق. + +### Mirror {#mirror} + +[Mirror](https://mirror.xyz/) هي منصة تدوين قائمة على Web3 تهدف أن تكون لامركزية ومملوكة للمستخدم. يمكن للمستخدمين القراءة والكتابة مجانًا على Mirror من خلال ربط محافظهم بها بسهولة. يمكن للمستخدمين أيضا جمع التدوينات، والاشتراك لدى المدونين المفضلين لديهم. + +تُخزن المشاركات المنشورة على Mirror للأبد في Arweave، وهي منصة تخزين لامركزية، ويمكن اعتبارها [كرموز مميوة غير قابلة للاستبدال](/nft/) المعروفة بـ NFTs للتويتات. يمكن للكُتّاب إنشاء تدوينات NFT مجانًا تمامًا، ويتم التجميع على الطبقة 2 من إثيريوم - مما يجعل المعاملات رخيصة وسريعة وصديقة للبيئة. + +### MINDS {#minds} + +[MINDS](https://www.minds.com/) هي إحدى أكثر المنصات الاجتماعية اللامركزية استخدامًا. وهي تعمل مثل Facebook وقد لاقت إقبال ملايين المستخدمين بالفعل. + +يستعمل المستخدمون الرمز المميز ERC-20 الأصلي للمنصة $MIND لدفع ثمن العناصر. يمكن للمستخدمين أيضًا كسب عملات $MIND المميزة من خلال نشر المحتوى العام، والمساهمة في النظام، وإحالة الآخرين إلى المنصة. + +## الشبكات الاجتماعية التقليدية لـ Web2 على إثيريوم {#web2-social-networks-and-ethereum} + +المنصات الاجتماعية الأصلية على [Web3](/web3/) ليست المنصات الوحيدة التي تحاول دمج تقنية سلاسل الكتل في وسائل التواصل الاجتماعي. تخطط العديد من منصات التواصل المركزية أيضًا لدمج شبكة إثيريوم في بنيتها التحتية: + +### Reddit {#reddit} + +تبنت منصة Reddit [ نقاط المجتمع](https://cointelegraph.com/news/reddit-to-reportedly-tokenize-karma-points-and-onboard-500m-new-users)، بواسطة [الرموز المميزة ERC-20](/developers/docs/standards/tokens/erc-20/) التي يمكن للمستخدمين أن يكسبوها عن طريق نشر محتوى مميز، والإسهام في المجتمعات عبر الإنترنت (subreddits). يمكنك استبدال هذه الرموز المميزة ضمن subreddit [للحصول على امتيازات ومزايا حصرية](https://www.reddit.com/community-points/). في هذا المشروع، تعمل شركة Reddit مع Arbitrum، وهي إحدى أنواع [الطبقة 2](/layer-2/) لحزم المعاملات المصممة لتوسيع معاملات إثيريوم. + +البرنامج نشط بالفعل مع العملة الرقمية من Subreddit [التي تشغل نسختها من نقاط المجتمع المُسماة"Moons"](https://www.reddit.com/r/CryptoCurrency/wiki/moons_wiki). وحسب الوصف الرسمي لـ Moons فهي "مكافآت يجنيها الناشرون، والمعلقون، والمنسقون مقابل مساهماتهم على subreddit". ولأن هذه الرموز المميزة موجودة على سلسلة الكتل (يستلمها المستخدمون على محافظهم)، فهي مستقلة عن Reddit ولا يمكن أخذها بعيدًا. + +بعد الانتهاء من مرحلة تجريبية على شبكة التجريب Rinkeby، أصبحت نقاط مجتمع Reddit الآن على [Arbitrum Nova](https://nova.arbitrum.io/)، وهي سلسلة كتلة تجمع خصائص [سلسلة جانبية](/developers/docs/scaling/sidechains/) و[تجميع متفائل](/developers/docs/scaling/optimistic-rollups/). بالإضافة إلى استخدام نقاط المجتمع لفتح الميزات الخاصة، يمكن للمستخدمين أيضًا الاتجار بها للحصول على المال في منصات التداول. كما أن كمية نقاط المجتمع التي يملكها المستخدم تحدد تأثيره على عملية صنع القرار داخل المجتمع. + +### Twitter {#twitter} + +في يناير/كانون ثاني 2021، أطلق Twitter Blue[ ميزة دعم لـ NFTs](https://mashable.com/article/twitter-blue-nft-profile-picture)، مما سمح للمستخدمين بربط محافظهم، وأتاح لهم عرض صور حساباتهم الشخصية كـ NFTs. وفي وقت كتابة هذا التقرير، فإن شركة التواصل الاجتماعي [أعلنت عن خطط](https://www.theverge.com/2021/8/16/22627435/twitter-bluesky-lead-jay-graber-decentralized-social-web) لإنشاء شبكة اجتماعية لامركزية في المستقبل. + +### Instagram {#instagram} + +في مايو/أيار 2022، أعلن [Instgram عن دعمه لـ NFTs](https://about.instagram.com/blog/announcements/instagram-digital-collectibles) على إثيريوم وPolygon. يمكن للمستخدمين نشر NFTs مباشرة على Instagram عن طريق الاتصال بمحفظة إثيريوم الخاصة بهم. + +## استخدام الشبكات الاجتماعية اللامركزية {#use-decentralized-social-networks} + +- **[Status.im](https://status.im/)** - _ Status هو تطبيق محادثة آمن ومفتوح المصدر، ويستخدم بروتوكول للنظراء، والتشفير من النهاية إلى النهاية لحماية رسائلك من تجسس الأطراف الثالثة._ +- **[Mirror.xyz](https://mirror.xyz/)** - _ Mirror هي منصة لامركزية النشر مملوكة للمستخدم مبنية على إثيريوم للمستخدمين لحشد الأفكار، وتحويل المحتوى إلى نقود، وبناء مجتمعات عالية القيمة._ +- **[بروتوكول Lens](https://lens.xyz/)** - _ بروتوكول Lens هو مخطط اجتماعي لامركزي قابل للتعميم يساعد المبدعين على امتلاك محتواهم الخاص أينما يذهبون في العالم الرقمي للإنترنت اللامركزي._ +- **[Farcaster](https://farcaster.xyz/)** - _ Farcaster هي شبكة اجتماعية لامركزية بدرجة كافية. إنه بروتوكول مفتوح يمكنه دعم العديد من العملاء، تمامًا مثل البريد الإلكتروني._ + +## قراءة إضافية {#further-reading} + +### المقالات {#articles} + +- [Decentralizing social media: a guide to the web3 social stack (وسائل التواصل الاجتماعي اللامركزية: دليل إلى حزمة Web3 الاجتماعية)](https://www.coinbase.com/blog/decentralizing-social-media-a-guide-to-the-web3-social-stack) - _صفقات قاعدة العملات_ +- [Social Networks Are the Next Big Decentralization Opportunity (الشبكات الاجتماعية هي االفرصة الكبرى القادمة للامركزية)](https://www.coindesk.com/tech/2021/01/22/social-networks-are-the-next-big-decentralization-opportunity/) — _بنبن جيرتزل_ +- [Web3 holds the promise of decentralized, community-powered social networks (يبشر Web3 بشبكات اجتماعية لامركزية مدعومة من المجتمع](https://venturebeat.com/2022/02/26/web3-holds-the-promise-of-decentralized-community-powered-social-networks/) - _سوميت جوش_ +- [An Overview of the Blockchain Social Media Landscape (نظرة عامة على وسائل التواصل الاجتماعي لسلسلة الكتلة](https://www.gemini.com/cryptopedia/blockchain-social-media-decentralized-social-media) — _Gemini Cryptopedia_ +- [Sufficient Decentralization for Social Networks (لامركزية كافية للشبكات الاجتماعية](https://www.varunsrinivasan.com/2022/01/11/sufficient-decentralization-for-social-networks) _فارون سرينيفاسان_ + +### مقاطع الفيديو {#videos} + +- [Decentralized Social Media Explained (شرح وسائل التواصل اللامركزية)](https://www.youtube.com/watch?v=UdT2lpcGvcQ) — _Coinmarketcap_ +- [DeSo Blockchain Wants to Decentralize Social Media (سلسلة كتلة DeSo تسعى لإلغاء مركزية وسائل التواصل)](https://www.youtube.com/watch?v=SG2HUiVp0rE) — _Bloomberg Technology_ +- [The Future of Decentralized Social Media (مستقبل وسائل التواصل اللامركزية)w/ Balaji Srinivasan, Vitalik Buterin, Juan Benet](https://www.youtube.com/watch?v=DTxE9KV3YrE) — _ETHGlobal_ + +### المجتمعات {#communities} + +- [خادم خلاف Status](https://discord.com/invite/3Exux7Y) +- [خادم خلاف Mirror](https://discord.com/invite/txuCHcE8wV) +- [r/CryptoCurrency subreddit](https://www.reddit.com/r/CryptoCurrency/) diff --git a/src/content/translations/az/nft/index.md b/src/content/translations/az/nft/index.md new file mode 100644 index 00000000000..7d1c20f54c6 --- /dev/null +++ b/src/content/translations/az/nft/index.md @@ -0,0 +1,356 @@ +--- +title: Bir-birini əvəz edə bilməyən nişanlar (NFT) +description: Ethereum-da NFT-lərə ümumi baxış +lang: az +template: use-cases +emoji: ":frame_with_picture:" +sidebarDepth: 2 +image: ../../../../assets/infrastructure_transparent.png +alt: Holoqram ilə görüntülənən bir Eth loqosu. +summaryPoint1: Ethereum əsaslı aktiv kimi bənzərsiz hər şeyi təmsil etmək üçün bir yol. +summaryPoint2: NFT-lər məzmun yaradıcılarına əvvəlkindən daha çox güc verir. +summaryPoint3: Ethereum blokçeynində ağıllı müqavilələr ilə təchiz edilmişdir. +--- + +NFT-lər hazırda rəqəmsal sənət və kolleksiya dünyasını fırtınaya bürüyüb. Rəqəmsal sənətçilər yeni kripto auditoriyasına böyük satışlar sayəsində həyatlarının dəyişdiyini görürlər. Məşhurlar da fanatları ilə əlaqə yaratmaq üçün yeni fürsət tapdıqları üçün qoşulurlar. Ancaq rəqəmsal sənət NFT-lərdən istifadə etməyin yalnız bir yoludur. Həqiqətən, onlar rəqəmsal və ya fiziki aləmdə bir obyekt üçün sənəd kimi hər hansı bir unikal aktivin mülkiyyətini təmsil etmək üçün istifadə edilə bilər. + +Andy Warhol 90-cı illərin sonlarında anadan olsaydı, yəqin ki, Campbell's Soup-nu NFT kimi zərb edərdi. Nike-ın Ethereum-da Jordans seriyasını qoyması yalnız vaxt məsələsidir. Və bir gün avtomobilinizə sahib olmaq NFT ilə sübut edilə bilər. + +## NFT nədir? {#what-are-nfts} + +NFT-lər unikal əşyaların sahibliyini təmsil etmək üçün istifadə edə biləcəyimiz tokenlərdir. İncəsənət, kolleksiya əşyaları, hətta daşınmaz əmlak kimi şeyləri tokenləşdirməyə imkan verirlər. Aktivin mülkiyyəti Ethereum blokçeyni ilə təmin edilir – heç kim sahiblik qeydini dəyişdirə və ya yeni NFT-ni kopyalaya/yapışdıra bilməz. + +NFT bir-birini əvəz edə bilməyən nişanə deməkdir. Qeyri-işlək, mebel, mahnı faylı və ya kompüteriniz kimi şeyləri təsvir etmək üçün istifadə edə biləcəyiniz iqtisadi termindir. Bu əşyalar digər əşyalarla əvəz edilə bilməz, çünki onların unikal xüsusiyyətləri var. + +Digər tərəfdən, dəyişdirilə bilən elementlər dəyişdirilə bilər, çünki onların unikal xüsusiyyətlərini deyil, dəyəri onları müəyyən edir. Məsələn, ETH və ya dollarlar dəyişdirilə bilər, çünki 1 ETH / $1 USD başqa 1 ETH / $1 USD ilə dəyişdirilə bilər. + + + +## Aktivlərin interneti {#internet-of-assets} + +NFT-lər və Ethereum bu gün internetdə mövcud olan bəzi problemləri həll edir. Hər şey daha rəqəmsallaşdıqca, fiziki elementlərin çatışmazlıq, unikallıq və mülkiyyət sübutu kimi xüsusiyyətlərini təkrarlamağa ehtiyac var. Rəqəmsal əşyaların çox vaxt yalnız məhsullarının kontekstində işlədiyini qeyd etmək olmaz. Məsələn, siz satın aldığınız iTunes mp3-ü yenidən sata bilməzsiniz və ya bazar mövcud olsa belə, bir şirkətin loyallıq xallarını başqa platformanın krediti ilə dəyişə bilməzsiniz. + +Bu gün çoxumuzun istifadə etdiyi internetlə müqayisədə NFT interneti necə görünür... + +### Müqayisə {#nft-comparison} + +| NFT interneti | İnternet bu gün | +| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| NFT-lər rəqəmsal olaraq unikaldır, heç bir iki NFT eyni deyil. | .mp3 və ya .jpg kimi faylın surəti orijinal ilə eynidir. | +| Hər bir NFT-nin sahibi olmalıdır və bu, ictimai qeyddədir və hər kəsin təsdiq etməsi asandır. | Rəqəmsal əşyaların mülkiyyət qeydləri qurumlar tərəfindən idarə olunan serverlərdə saxlanılır – yeganə seçiminiz onlara etibar etməkdir. | +| NFT-lər Ethereum istifadə edərək qurulmuş hər şeyə uyğun gəlir. Tədbir üçün NFT bileti hər Ethereum bazarında tamamilə fərqli bir NFT üçün satıla bilər. Bir sənət əsərini biletə dəyişə bilərsiniz! | Rəqəmsal elementləri olan şirkətlər öz infrastrukturlarını qurmalıdırlar. Məsələn, tədbirlər üçün rəqəmsal biletlər verən proqram öz bilet mübadiləsini qurmalı olacaq. | +| Məzmun yaradıcıları işlərini hər yerdə sata və qlobal bazara çıxa bilərlər. | Yaradıcılar istifadə etdikləri platformaların infrastrukturuna və paylanmasına etibar edirlər. Bunlar çox vaxt istifadə şərtlərinə və coğrafi məhdudiyyətlərə məruz qalır. | +| Yaradıcılar öz işləri üzərində sahiblik hüquqlarını saxlaya və birbaşa satış qonorarı tələb edə bilərlər. | Musiqi axını xidmətləri kimi platformalar satışdan əldə edilən gəlirin böyük hissəsini özündə saxlayır. | +| Maddələr maraqlı yollarla istifadə edilə bilər. Məsələn, mərkəzləşdirilməmiş kreditdə girov kimi rəqəmsal sənət əsərlərindən istifadə edə bilərsiniz. | | + +### NFT nümunələri {#nft-examples} + +NFT dünyası nisbətən yenidir. Nəzəri olaraq, NFT-lərin əhatə dairəsi sübut edilə bilən mülkiyyətə ehtiyacı olan unikal olan hər şeydir. NFTS anlayışını başa düşməyə kömək etmək üçün bu gün mövcud olan bəzi NFT nümunələri bunlardır: + +- [Unikal rəqəmsal sənət əsəri](https://foundation.app/artworks) +- [Məhdud buraxılışlı moda xəttində unikal tenis ayaqqabısı](https://www.metagrail.co/auctions/91cf83fb-3477-4155-aae8-6dcb9b853397) +- [Oyundaxili element](https://market.decentraland.org/) +- [İnşa](https://zora.co/0x517bab7661C315C63C6465EEd1b4248e6f7FE183/145) +- [Rəqəmsal kolleksiya](https://www.larvalabs.com/cryptopunks/details/1) +- [Domen adı](https://app.ens.domains/name/ethereum.eth) +- [Tədbirə və ya kupona giriş imkanı verən bilet](https://www.yellowheart.io/) +- [Real dünya malları alın](https://www.tangible.store/) +- [Fraksiyalı daşınmaz əmlak](https://realt.co/) +- [Dərəcə Sertifikatlar](https://www.degreecert.com/) +- [NFT vasitəsilə musiqi qonorarı](https://opulous.org/) +- [Qazanmaq üçün hərəkət edin](https://yeticoineth.com/about.html) +- [Rəqəmsal şəxsiyyət](https://photochromic.io/) + +### ethereum.org nümunələri {#ethereum-org-examples} + +Biz töhfə verənlərə geri qaytarmaq üçün NFT-lərdən istifadə edirik və hətta öz NFT domen adımız da var. + +#### POAP-lar (İştirak protokolunun sübutu) {#poaps} + +Ethereum.org-a töhfə versəniz, POAP NFT-ni tələb edə bilərsiniz. Bunlar tədbirdə iştirak etdiyinizi sübut edən kolleksiyalardır. Bəzi kriptovalyuta görüşləri öz tədbirlərinə bilet forması kimi POAP-lardan istifadə etdilər. [Töhfə haqqında daha çox məlumat](/contributing/#poap). + +![ethereum.org POAP](./poap.png) + +#### ethereum.eth {#ethereum-dot-eth} + +Bu veb-saytın NFT-lər tərəfindən dəstəklənən alternativ domen adı var, **ethereum.eth**. Bizim `.org` ünvanımız mərkəzləşdirilmiş şəkildə domen adı sistemi (DNS) provayderi tərəfindən idarə olunur, halbuki ethereum`.eth` Ethereum Ad Xidməti (ENS) vasitəsilə Ethereum-da qeydiyyatdan keçib. Və bizə məxsusdur və idarə olunur. [ENS qeydimizi yoxlayın](https://app.ens.domains/name/ethereum.eth) + +[ENS haqqında daha çox](https://app.ens.domains) + +## NFT-lər necə işləyir? {#how-nfts-work} + +NFT-lər DAI və ya LINK kimi ERC-20 tokenlərindən fərqlidir ki, hər bir fərdi token tamamilə unikaldır və bölünmür. NFT-lər Ethereum-un blokçeynindən ictimai kitab kimi istifadə etməklə izlənilə bilən istənilən unikal rəqəmsal məlumat parçasına sahiblik təyin etmək və ya iddia etmək imkanı verir. NFT rəqəmsal obyektlərdən rəqəmsal və ya qeyri-rəqəmsal aktivlərin təsviri kimi hazırlanır. Məsələn, NFT aşağıdakıları təmsil edə bilər: + +- Rəqəmsal sənət: + - GİFlər + - Kolleksiyalar + - Musiqi + - Videolar +- Real Dünya Elementləri: + - Avtomobil sənədləri + - Real dünya tədbirlərinə biletlər + - Tokenləşdirilmiş fakturalar + - Hüquqi sənədlər + - İmzalar +- Yaradıcı olmaq üçün daha çox seçim! + +NFT-lərə sahiblik başqa heç bir tokenin təkrarlaya bilmədiyi unikal ID və metadata vasitəsilə idarə olunur. NFT-lər sahibliyi təyin edən və NFT-lərin ötürülməsini idarə edən ağıllı müqavilələr vasitəsilə hazırlanır. Kimsə NFT yaratdıqda və ya zərb edəndə, [ERC-721](/developers/docs/standards/tokens/erc-721/) kimi müxtəlif standartlara uyğun gələn ağıllı müqavilələrdə saxlanılan kodu icra edir. Bu məlumat NFT-nin idarə olunduğu blokçeynə əlavə edilir. Zərb prosesi, yüksək səviyyədən keçdiyi aşağıdakı addımlardan ibarətdir: + +- Yeni blok yaradılması +- Məlumatın təsdiqlənməsi +- Blokçeynə məlumatların qeyd edilməsi + +NFT-lərin bəzi özəl xüsusiyyətləri var: + +- Zərb olunan hər bir tokenin bir Ethereum ünvanı ilə birbaşa əlaqəli olan unikal identifikatoru var. +- Onlar 1:1 nisbətində digər tokenlərlə birbaşa əvəz edilə bilməz. Məsələn, 1 ETH başqa bir ETH ilə eynidir. NFT-lərdə belə deyil. +- Hər bir tokenin sahibi var və bu məlumat asanlıqla yoxlanıla bilər. +- Onlar Ethereum-da yaşayırlar və istənilən Ethereum əsaslı NFT bazarında alınıb satıla bilərlər. + +Başqa sözlə, əgər NFT-yə _sahibisinizsə_: + +- Siz asanlıqla ona sahib olduğunuzu sübut edə bilərsiniz. + - NFT-yə sahib olduğunuzu sübut etmək, hesabınızda ETH-nin olduğunu kimi sübut etməyə çox bənzəyir. + - Məsələn, deyək ki, siz NFT aldınız və unikal tokenin mülkiyyəti ümumi ünvanınız vasitəsilə pulqabıya köçürülür. + - Token rəqəmsal faylın surətinizin orijinal olduğunu sübut edir. + - Şəxsi açarınız orijinalın sahibliyini sübut edir. + - Məzmun yaradıcısının açıq açarı həmin xüsusi rəqəmsal artefakt üçün orijinallıq sertifikatı kimi xidmət edir. + - Yaradıcıların açıq açarı əslində token tarixinin daimi hissəsidir. Yaradıcının açıq açarı nümayiş etdirə bilər ki, sizdə olan token müəyyən bir şəxs tərəfindən yaradılıb və beləliklə, onun bazar dəyərinə töhfə verir (saxtakarlığa qarşı). + - NFT-yə sahib olduğunuzu sübut etmək barədə düşünməyin başqa bir yolu, ünvanın arxasındakı şəxsi açara sahib olduğunuzu sübut etmək üçün mesajlar imzalamaqdır. + - Yuxarıda qeyd edildiyi kimi, şəxsi açarınız orijinalın mülkiyyətinin sübutudur. Bu, həmin ünvanın arxasındakı şəxsi açarların NFT-ni idarə etdiyini bildirir. + - İmzalanmış mesaj şəxsi açarlarınızı heç kimə açıqlamadan və beləliklə də NFT-yə sahib olduğunuzu sübut edən sübut kimi istifadə edilə bilər! +- Heç kim onu heç bir şəkildə manipulyasiya edə bilməz. +- Siz onu sata bilərsiniz və bəzi hallarda bu, orijinal yaradıcının yenidən satış qonorarı qazanacaq. +- Və ya aktivinizin Ethereum-dakı pulqabı tərəfindən qorunduğunu bilə-bilə rahat istirahət edərək onu əbədi saxlaya bilərsiniz. + +Siz NFT yaratdığınız zaman: + +- Asanlıqla müəllif olduğunuzu sübut edə bilərsiniz. +- Onun nadirliyini seçə bilərsiniz. +- Hər satışdan pay ala bilərsiniz. +- Onu NFT marketlərində və ya digər insanlara sata bilərsiniz. Sizə heç bir platformada əngəl yoxdur və aracı olacaq birinə ehtiyac duymayacaqsınız. + +### Qıtlıq {#scarcity} + +NFT-nin yaradıcısı aktivlərinin qıtlığına qərar verir. + +Məsələn, bir idman tədbirinə bilet düşünün. Tədbirin təşkilatçısı neçə bilet satacağını seçə bildiyi kimi, NFT-nin yaradıcısı da neçə replikanın mövcudluğuna qərar verə bilər. Bəzən bunlar 5000 Ümumi Qəbul biletləri kimi dəqiq replikalardır. Bəzən çox oxşar, lakin hər biri bir qədər fərqli olan bir neçə zərb edilir, məsələn, təyin edilmiş oturacaqlı bilet. Başqa bir halda, yaradıcı yalnız birinin xüsusi nadir kolleksiya kimi zərb edildiyi NFT yaratmaq istəyə bilər. + +Bu hallarda, hər bir NFT hələ də yalnız bir sahibi ilə unikal identifikatora (ənənəvi "biletdəki" ştrix kod kimi) malik olacaq. NFT-nin nəzərdə tutulan çatışmazlığı əhəmiyyətlidir və yaradıcıdan asılıdır. Yaradıcı çatışmazlıq yaratmaq üçün hər bir NFT-ni tamamilə unikal etmək niyyətində ola bilər və ya bir neçə min replika istehsal etmək üçün səbəbləri ola bilər. Unutmayın ki, bu məlumatların hamısı açıqdır. + +### Qonorarlar {#royalties} + +Bəzi NFT-lər satıldıqda müəlliflərinə avtomatik olaraq qonorar ödəyəcəklər. Bu hələ inkişaf etməkdə olan bir konsepsiyadır, lakin ən güclülərindən biridir. [EulerBeats Originals](https://eulerbeats.com/)-ın orijinal sahibləri NFT hər dəfə satıldıqda 8% royalti qazanırlar. Və [Foundation](https://foundation.app) və [Zora](https://zora.co/) kimi bəzi platformalar öz sənətçiləri üçün qonorarları dəstəkləyirlər. + +Bu, tamamilə avtomatikdir, ona görə də yaradıcılar sadəcə oturub qonorar qazana bilərlər, çünki işləri şəxsdən şəxsə satılır. Hazırda qonorarları müəyyən etməkdə əl ilə hesablanır və dəqiqlik yoxdur – bir çox yaradıcılar layiq olduqları pulu almırlar. Əgər NFT-nizdə ona proqramlaşdırılmış bir royalti varsa, heç vaxt əldən verməyəcəksiniz. + +## NFT-lər nə üçün istifadə olunur? {#nft-use-cases} + +Ethereum-da NFT-lər üçün daha yaxşı işlənmiş istifadə halları və baxışları haqqında daha çox məlumat buradadır. + +- [Rəqəmsal məzmun](#nfts-for-creators) +- [Oyun elementləri](#nft-gaming) +- [Domen adları](#nft-domains) +- [Fiziki elementlər](#nft-physical-items) +- [İnvestisiya və girov](#nfts-and-defi) +- [Tokenqeytinq](#tokengating) + + + +### Yaradıcılar üçün qazancın artırılması {#nfts-for-creators} + +Bu gün NFT-lərin ən böyük istifadəsi rəqəmsal məzmun sahəsindədir. Çünki bu gün həmin sənaye yaxşı işləmir. Məzmun yaradıcıları qazanclarının və qazanc potensialının platformalar tərəfindən udulduğunu görürlər. + +Sosial şəbəkədə əsər dərc edən bir sənətçi, sənətçilərin izləyicilərinə reklam satan platforma üçün pul qazanır. Bunun müqabilində ifşa alırlar, lakin ifşa hesabları ödəmir. + +NFT-lər yeni yaradıcı iqtisadiyyatı gücləndirir, burada yaradıcılar onların məzmununa sahiblik hüququnu ictimailəşdirmək üçün istifadə etdikləri platformalara təhvil vermirlər. Mülkiyyət məzmunun özündədir. + +Məzmunu satdıqda, vəsait birbaşa onlara gedir. Əgər yeni sahib NFT-ni satarsa, orijinal yaradıcı hətta avtomatik olaraq qonorar ala bilər. Bu, hər dəfə satıldıqda zəmanət verilir, çünki yaradıcının ünvanı token metadatasının bir hissəsidir – dəyişdirilə bilməyən metadata. + + +
Öz NFT sənətinizi/kolleksiyalarınızı kəşf edin, alın və ya yaradın...
+ + NFT sənətini araşdırın + + + +#### Kopyalama/yapışdırma problemi {#nfts-copy-paste} + +Şübhə edənlər tez-tez NFT-lərin "lal" olduqlarını, ümumiyyətlə NFT sənət əsərinin ekran görüntüsünü çəkdikləri bir şəkil ilə birlikdə gündəmə gətirirlər. "Bax, indi o görüntü məndə pulsuzdur!" lovğalıqla deyirlər. + +Yaxşı, bəli. Bəs Pikassonun Guernica-nın şəklini axtarmaq sizi çox milyon dollarlıq sənət tarixinin qürurlu yeni sahibi edirmi? + +Nəhayət, real bir şeyə sahib olmaq bazarın etdiyi qədər dəyərlidir. Bir məzmun parçası ekranda nə qədər çox tutulsa, paylaşılsa və ümumiyyətlə istifadə edilərsə, bir o qədər dəyər qazanır. + +Doğrulana bilən real bir şeyə sahib olmaq həmişə yoxdan daha çox dəyərə malik olacaqdır. + + + +### Oyun potensialının artırılması {#nft-gaming} + +NFT-lər oyun tərtibatçıları tərəfindən böyük maraq gördü. NFT-lər oyundaxili əşyalar üçün sahiblik qeydlərini təqdim edə, oyundaxili iqtisadiyyatları gücləndirə və oyunçulara bir sıra faydalar gətirə bilər. + +Bir çox adi oyunlarda siz oyununuzda istifadə etmək üçün əşyalar ala bilərsiniz. Amma əgər həmin əşya NFT idisə, oyunu bitirdikdən sonra onu satmaqla pulunuzu geri qaytara bilərsiniz. Bu maddə daha arzuolunan olarsa, hətta qazanc əldə edə bilərsiniz. + +Oyun tərtibatçıları üçün - NFT-nin emitentləri kimi - hər hansı bir maddə açıq bazarda yenidən satıldıqda qonorar qazana bilərdilər. Bu, həm oyunçuların, həm də tərtibatçıların təkrar NFT bazarından qazandıqları daha qarşılıqlı faydalı biznes modeli yaradır. + +Bu həm də o deməkdir ki, tərtibatçılar artıq oyunu dəstəkləmirlərsə, topladığınız əşyalar sizə qalır. + +Nəticədə oyunda əldə etdiyiniz elementlər oyunların özündən çox yaşaya bilər. Bir oyun artıq mövcud olmasa belə, elementlər həmişə sizin nəzarətinizdə olacaq. Bu o deməkdir ki, oyundaxili elementlər rəqəmsal yaddaşa çevrilir və oyundan kənarda dəyərə malikdir. + +Virtual reallıq oyunu olan Decentraland hətta sizə uyğun gördüyünüz kimi istifadə edə biləcəyiniz virtual torpaq sahələrini təmsil edən NFT-ləri almağa imkan verir. + + +
NFT-lər tərəfindən dəstəklənən Ethereum oyunlarına baxın...
+ + NFT oyunlarını araşdırın + + + + + +### Ethereum ünvanlarını daha yaddaqalan etmək {#nft-domains} + +Ethereum Ad Xidməti Ethereum ünvanınızı `mywallet.eth` kimi daha asan yadda qalan adla təmin etmək üçün NFT-lərdən istifadə edir. Bu o deməkdir ki, kimsədən sizə ETH göndərməsini `0x123456789.....` əvəzinə `mywallet.eth` vasitəsilə göndərə bilərsiniz. + +Bu, bir IP ünvanını daha yaddaqalan edən veb-sayt domen adına oxşar şəkildə işləyir. Və domenlər kimi, ENS adları da adətən uzunluğa və uyğunluğa əsaslanan dəyərə malikdir. ENS ilə mülkiyyətin ötürülməsini asanlaşdırmaq üçün domen reyestrinə ehtiyacınız yoxdur. Bunun əvəzinə siz ENS adlarınızı NFT bazarında ticarət edə bilərsiniz. + +ENS adınız ola bilər: + +- Kriptovalyutanı və digər NFT-ləri əldə edin. +- [ethereum.eth](https://ethereum.eth.link) kimi mərkəzləşdirilməmiş veb-sayta işarə edin. [Veb-saytınızın mərkəzsizləşdirilməsi haqqında daha çox məlumat](https://docs.ipfs.io/how-to/websites-on-ipfs/link-a-domain/#domain-name-service-dns) +- E-poçt ünvanları və Twitter tutacaqları kimi profil məlumatları daxil olmaqla istənilən ixtiyari məlumatı saxlayın. + + + +### Fiziki elementlər {#nft-physical-items} + +Fiziki əşyaların tokenizasiyası hələ rəqəmsal həmkarları qədər inkişaf etməmişdir. Ancaq daşınmaz əmlakın tokenizasiyasını, bənzərsiz moda əşyalarını və daha çoxunu araşdıran çoxlu layihələr var. + +NFT-lər əslində mülkiyyət sənədləri olduğundan, bir gün siz ETH-dən istifadə edərək avtomobil və ya ev ala bilərsiniz və əvəzində (eyni əməliyyatda) sənədi NFT kimi ala bilərsiniz. İşlər getdikcə yüksək texnologiyaya çevrildikcə, Ethereum cüzdanınızın avtomobilinizin və ya evinizin açarına çevrildiyi dünyanı təsəvvür etmək çətin deyil – sahibliyin kriptoqrafik sübutu ilə qapınızın kilidi açılır. + +Avtomobillər və Ethereum-da təmsil olunan əmlak kimi qiymətli aktivlərlə, NFT-ləri mərkəzləşdirilməmiş kreditlərdə girov kimi istifadə edə bilərsiniz. Nağd pul və ya kriptovalyuta ilə zəngin deyilsinizsə, lakin dəyərli fiziki əşyalarınız varsa, bu xüsusilə faydalıdır. [DeFi haqqında daha çox məlumat](/defi/) + + + +### NFT-lər və DeFi {#nfts-and-defi} + +NFT dünyası və [mərkəzləşdirilməmiş maliyyə (DeFi)](/defi/) dünyası bir sıra maraqlı üsullarla birlikdə işləməyə başlayır. + +#### NFT-dəstəklənən kreditlər {#nft-backed-loans} + +Girovdan istifadə edərək borc götürməyə imkan verən DeFi proqramları var. Məsələn, 5000 DAI ([stablecoin](/stablecoins/)) borc ala bilmək üçün 10 ETH-ni girov qoyursunuz. Bu, borc verənin geri ödənilməsinə zəmanət verir - borcalan DAI-ni geri qaytarmazsa, girov borc verənə göndərilir. Bununla belə, hər kəsin girov kimi istifadə etmək üçün kifayət qədər kriptovalyutası yoxdur. + +Layihələr əvəzinə NFT-ləri girov kimi istifadə edərək araşdırmağa başlayırlar. Təsəvvür edin ki, siz vaxtilə nadir bir CryptoPunk NFT aldınız – onlar bugünkü qiymətlərlə 1000 dollar ala bilərlər. Bunu girov kimi qoymaqla siz eyni qayda dəsti ilə kredit əldə edə bilərsiniz. DAI-ni geri qaytarmasanız, CryptoPunk borc verənə girov olaraq göndəriləcək. Bu, nəticədə NFT kimi işarələdiyiniz hər şeylə işləyə bilər. + +Və bu Ethereum üçün çətin deyil, çünki hər iki dünya (NFT və DeFi) eyni infrastrukturu paylaşır. + +#### Fraksiyalı mülkiyyət {#fractional-ownership} + +NFT yaradıcıları həmçinin öz NFT üçün "paylar" yarada bilərlər. Bu, investorlara və azarkeşlərə hər şeyi satın almadan NFT-nin bir hissəsinə sahib olmaq imkanı verir. Bu, həm NFT həmkarları və kolleksiyaçılar üçün daha çox imkanlar əlavə edir. + +- Fraksiyalaşdırılmış NFT-lər yalnız [NFT bazarlarında](/dapps?category=collectibles) deyil, Uniswap kimi [DEX-lərdə](/defi/#dex) satıla bilər. Bu, daha çox alıcı və satıcı deməkdir. +- NFT-nin ümumi qiyməti onun fraksiyalarının qiyməti ilə müəyyən edilə bilər. +- Önəm verdiyiniz əşyalara sahib olmaq və onlardan qazanc əldə etmək üçün daha çox imkanınız var. NFT-lərə sahib olmaqdan qiymət almaq daha çətindir. + +Bu hələ eksperimentaldır, lakin siz aşağıdakı mübadilələrdə fraksiya NFT sahibliyi haqqında daha çox öyrənə bilərsiniz: + +- [NIFTEX](https://landing.niftex.com/) +- [NFTX](https://gallery.nftx.org/) + +Nəzəri olaraq, bu, Pikassonun bir parçasına sahib olmaq kimi şeylər etmək imkanını açacaq. Siz Picasso NFT-nin səhmdarı olacaqsınız, yəni gəlirin bölüşdürülməsi kimi məsələlərdə söz sahibi olacaqsınız. Çox güman ki, bir gün tezliklə NFT-nin bir hissəsinə sahib olmaq sizi həmin aktivi idarə etmək üçün mərkəzləşdirilməmiş muxtar təşkilata (DAO) daxil edəcək. + +Bunlar, bir aktivin qlobal səhmdarları kimi kənar şəxslərə digər insanlara etibar etmədən təhlükəsiz şəkildə koordinasiya etməyə imkan verən Ethereum tərəfindən dəstəklənən təşkilatlardır. Çünki qrupun razılığı olmadan bir qəpik də xərclənə bilməz. + +Qeyd etdiyimiz kimi, bu, inkişaf edən bir məkandır. NFT-lər, DAO-lar fraksiyalaşdırılmış tokenlər müxtəlif sürətlə inkişaf edir. Lakin onların bütün infrastrukturu mövcuddur və asanlıqla birlikdə işləyə bilər, çünki hamısı eyni dildə danışır: Ethereum. Beləliklə, bu məkana baxın. + +[More on DAOs](/dao/) + +### Orijinallıq sertifikatları {#certificates} + +Universitet dərəcələri üçün saxta sertifikatlar təklif edən şirkətlərin NFT-lərin mübarizə apara biləcəyi milyard dollarlıq sənaye olduğu bildirilir. NFT-lər kiminsə dərəcə etimadnaməsini yoxlamaq üçün təhlükəsiz və sürətli bir yol ola bilər. + +[Cənubi Koreyada bir universitet artıq NFT kimi dərəcə sertifikatları verir](https://forkast.news/headlines/south-korea-nfts-graduates-hoseo/). NFTs inzibati xidmətlərə çıxışı yaxşılaşdıracaq və dərəcənin saxtalaşdırılmasının və ya dəyişdirilməsinin qarşısını alacaq. [İrlandiyadakı Trinity Business School (TBS) də 2023-cü ildən NFT təklif etməyi planlaşdırır](https://trinitynews.ie/2022/04/business-school-to-offer-degree-nfts/). + + + +### Tokenqeytinq {#tokengating} + +Tokenqeytinq bir şeyə girişi məhdudlaşdırmaq və girişin kilidini açmaq üçün NFT-lərdən istifadə etmək üsuludur. Bunlar platformadan asılı olaraq çox dəyişə bilər, lakin məşhur nümunələr qapalı məzmun, şəxsi söhbət serverləri və e-ticarət dünyasında eksklüziv məhsullardır. + +Tokengating edən platforma tələb olunan NFT-yə sahib olduğunuzu sübut etmək üçün sizdən pulqabını birləşdirməyi istəyəcək. Əgər sizə lazım olan NFT varsa, giriş əldə edəcəksiniz. Əks halda, şey qapalı qalacaq. NFT-lər unikallığına görə bunu etmək üçün əla bir yoldur - əşyanı əldə etmək üçün saxta sahiblik edə bilməzsiniz. + +NFT-lər unikallığına görə bunu etmək üçün əla bir yoldur - əşyanı əldə etmək üçün saxta sahiblik edə bilməzsiniz. Sahib olduğunuz tək bir NFT tamamilə fərqli veb-saytlar və tətbiqlərdə qapalı məzmunu, şəxsi söhbət serverlərini və eksklüziv məhsulların kilidini aça bilər. + +NFT-lərin zərb edilməsi və paylanması icma nəsli və ya icmanın rəqəmsallaşdırılması ilə əlaqədardırsa, tokenqating cəmiyyətin tərbiyəsi ilə bağlıdır. O, NFT-lərin daha çox üzvlük və ya sadiqlik üçün bir vasitə kimi istifadə edildiyini və onunla gələn mükafatları etibarlı şəkildə çatdırmaq üçün əla bir yol olduğunu görür. + +#### Examples + +- [Collab.land](https://collab.land/) tokenqeyt Discord çat serverləri və ya Telegram qrupları +- [Kilidi açma protokolu](https://unlock-protocol.com/) tokenqeytinq üçün protokoldur +- [Shopify](https://help.shopify.com/en/manual/products/digital-service-product/nfts) tacirlərə məhsullara və endirimlərə giriş imkanı verən tətbiqlərin artan siyahısına malikdir + + + +## Ethereum və NFT-lər {#ethereum-and-nfts} + +Ethereum NFT-lərin bir sıra səbəblərə görə işləməsini mümkün edir: + +- Tranzaksiya tarixçəsi və token metadata açıq şəkildə yoxlana bilər – sahiblik tarixçəsini sübut etmək asandır. +- Tranzaksiya təsdiq edildikdən sonra, sahibliyi "oğurlamaq" üçün həmin məlumatları manipulyasiya etmək demək olar ki, mümkün deyil. +- Ticarət NFT-ləri kompensasiya olaraq böyük endirimlər götürə bilən platformalara ehtiyac duymadan həmyaşıdlar arasında baş verə bilər. +- Bütün Ethereum məhsulları eyni “backend”i paylaşır. Başqa sözlə, bütün Ethereum məhsulları bir-birini asanlıqla başa düşə bilər - bu, NFT-ləri məhsullar arasında portativ edir. Siz bir məhsul üçün NFT alıb digərində asanlıqla sata bilərsiniz. Yaradıcı olaraq NFT-lərinizi eyni vaxtda birdən çox məhsulda siyahıya sala bilərsiniz – hər bir məhsulda ən müasir sahiblik məlumatı olacaq. +- Ethereum heç vaxt aşağı düşmür, yəni tokenləriniz həmişə satıla bilər. + +## NFT-lərin ətraf mühitə təsiri {#environmental-impact-nfts} + +NFT-lərin yaradılması və ötürülməsi sadəcə Ethereum əməliyyatlarıdır - pul çıxarmaq, almaq, dəyişdirmək və ya NFT-lərlə qarşılıqlı əlaqə birbaşa enerji sərf etmir. [Birləşmə](/roadmap/merge) olduğundan, Ethereum aşağı enerjili blokçeyndir, yəni NFT-lərdən istifadənin ətraf mühitə təsiri cüzidir. + +[Ethereum-un enerji istehlakı haqqında ətraflı](/energy-consumption/). + +### Bunu NFT-lərdə günahlandırmayın {#nft-qualities} + +Bütün NFT ekosistemi işləyir, çünki Ethereum mərkəzləşdirilməmiş və təhlükəsizdir. + +Mərkəzləşdirilməmiş o deməkdir ki, siz və hər kəs nəyəsə sahib olduğunuzu təsdiqləyə bilər. Hamısı öz qaydalarını istədiyi zaman tətbiq edə bilən üçüncü tərəfə etibar etmədən və ya qəyyumluq vermədən. Bu, həm də NFT-nin bir çox müxtəlif məhsul və bazarlarda daşına bilən olması deməkdir. + +Təhlükəsiz deməkdir ki, heç kim NFT-nizi kopyalaya/yapışdıra və ya oğurlaya bilməz. + +Ethereum-un bu keyfiyyətləri rəqəmsal olaraq unikal əşyalara sahib olmağı və məzmununuz üçün ədalətli qiymət əldə etməyi mümkün edir. Ethereum aktivləri ['proof-of-stake'](/developers/docs/consensus-mechanisms/pos) ehtiva edən mərkəzləşdirilməmiş konsensus mexanizmindən istifadə edərək qoruyur. Bu, zəncirə əməliyyatlar blokunu kimin əlavə edə biləcəyini müəyyən etmək üçün aşağı karbonlu bir üsuldur və enerji tutumlu alternativdən daha təhlükəsiz hesab olunur,['proof-of-work'](/developers/docs/consensus-mechanisms/pow). NFT-lər yüksək enerji xərcləri ilə əlaqələndirilmişdir, çünki Ethereum əvvəllər iş sübutu ilə təmin edilirdi. Bu artıq doğru deyil. + +#### NFT-lərin zərb edilməsi {#minting-nfts} + +Bir NFT zərb edəndə bir neçə şey baş verməlidir: + +- O, blokçeynində aktiv kimi təsdiqlənməlidir. +- Sahibin hesab balansı həmin aktivi daxil etmək üçün yenilənməlidir. Bu, onun daha sonra alqı-satqısına və ya yoxlanıla bilən şəkildə "sahibi" olmasına imkan verir. +- Yuxarıdakıları təsdiqləyən əməliyyatlar bloka əlavə edilməli və zəncirdə "ölümsüzləşdirilməlidir". +- Blok şəbəkədəki hər kəs tərəfindən "düzgün" olaraq təsdiqlənməlidir. Bu konsensus vasitəçilərə ehtiyacı aradan qaldırır, çünki şəbəkə sizin NFT-nin mövcudluğu və sizə aid olması ilə razılaşır. Və zəncirdədir ki, hər kəs onu yoxlaya bilsin. Bu, Ethereum-un NFT yaradıcılarına qazanclarını artırmaqda köməklik edən üsullardan biridir. + +Bütün bu tapşırıqlar blok istehsalçıları və validatorlar tərəfindən yerinə yetirilir. Blok təklif edənlər NFT əməliyyatınızı bloka əlavə edir və onu şəbəkənin qalan hissəsinə yayımlayır. Validatorlar əməliyyatın etibarlı olub olmadığını yoxlayır və sonra onu verilənlər bazalarına əlavə edirlər. Validatorların vicdanla hərəkət etdiyinə əmin olmaq üçün bir çox kripto-iqtisadi təşviqlər mövcuddur. Əks halda, hər kəs yenicə zərb etdiyiniz NFT-yə sahib olduqlarını iddia edə və fırıldaqçılıq yolu ilə sahibliyi ötürə bilər. + +#### NFT təhlükəsizliyi {#nft-security} + +Ethereum-un təhlükəsizliyi hissə sübutundan gəlir. Sistem zərərli hərəkətləri iqtisadi cəhətdən dayandırmaq üçün nəzərdə tutulmuşdur və bu, Ethereum-u müdaxiləyə davamlı edir. NFT-ləri mümkün edən budur. NFT əməliyyatınızı ehtiva edən blok tamamlandıqdan sonra onu dəyişdirmək təcavüzkarın milyonlarla ETH-yə başa gələcək. Ethereum proqramını işlədən hər kəs dərhal NFT-yə vicdansız müdaxiləni aşkar edə biləcək və pis aktyor iqtisadi cəhətdən cəzalandırılacaq və işdən çıxarılacaq. + +NFT-lərlə bağlı təhlükəsizlik məsələləri çox vaxt fişinq fırıldaqları, ağıllı müqavilə zəiflikləri və ya istifadəçi səhvləri (məsələn, şəxsi açarların təsadüfən ifşa edilməsi kimi) ilə əlaqədardır ki, bu da pul kisəsinin təhlükəsizliyini NFT sahibləri üçün kritik edir. + + + Təhlükəsizlik haqqında daha çox + + +## NFT ilə qurun {#build-with-nfts} + +Əksər NFT-lər [ERC-721](/developers/docs/standards/tokens/erc-721/) kimi tanınan ardıcıl standartdan istifadə etməklə qurulur. Bununla belə, baxmaq istəyə biləcəyiniz başqa standartlar da var. [ERC-1155](/developers/docs/standards/tokens/erc-1155/) standartı, xüsusilə də oyunlarda faydalı olan yarı ötürülmüş tokenlərə imkan verir. Və daha yaxınlarda, NFT-lərin zərb edilməsini daha səmərəli etmək üçün [EIP-2309](https://eips.ethereum.org/EIPS/eip-2309) təklif edilmişdir. Bu standart sizə bir əməliyyatda istədiyiniz qədər pul köçürməyə imkan verir! + +## Further reading {#further-reading} + +- [Kripto sənəti məlumatları](https://cryptoart.io/data) – Richard Chen, avtomatik yenilənir +- [OpenSea: the NFT Bible](https://opensea.io/blog/guides/non-fungible-tokens/) – _Devin Fizner, 10 yanvar 2020_ +- [NFT-lər üçün yeni başlayanlar üçün bələdçi](https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d) – _Linda Xie, yanvar 2020_ +- [Metaverse haqqında bilmək lazım olan hər şey](https://foundation.app/blog/enter-the-metaverse)– _Foundation komandası, foundation.app_ +- [Xeyr, CryptoArtists Planetə Zərər Etmir](https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61) +- [Ethereum's energy consumption](/energy-consumption/) +- [Ethereum NFT API-ləri](https://www.alchemy.com/list-of/nft-apis-on-ethereum) - _Kimya_ + + diff --git a/src/content/translations/de/community/online/index.md b/src/content/translations/de/community/online/index.md index d272abcfde5..b0f1aa14165 100644 --- a/src/content/translations/de/community/online/index.md +++ b/src/content/translations/de/community/online/index.md @@ -26,7 +26,7 @@ Hunderttausende von Ethereum-Enthusiasten treffen sich in diesen Online-Foren, u CryptoDevs - Auf Ethereum Entwicklung fokussierte Discord-Community EthStaker Discord - Gemeinschaft orientiert am Angebot von Projekt-Management-Unterstützung für Ethereum-Entwickler Ethereum.org Website-Team - Kommen Sie vorbei and schreiben Sie mit dem Team und anderen aus der Gemeinschaft über Ethereum.org Web-Entwicklung und Design -Matos Discord - Web3-Creator-Community, wo Entwickler, industrielle Führer, und Ethereum Enthusiasten abhängen. Wir sind begeistert von Web3-Entwicklung, Design und Kultur. Kommen Sie mit uns bauen. +Matos Discord - Web3-Creator-Community, wo sich Entwickler, industrielle Führer, und Ethereum Enthusiasten aufhalten. Wir sind begeistert von Web3-Entwicklung, Design und Kultur. Kommen Sie mit uns bauen. Solidity-Gitter - Unterhaltungen über Solidity-Entwicklung (Gitter) Solidity-Matrix - Unterhaltungen über Solidity-Entwicklung (Matrix) Ethereum Stack Exchange _– Forum für Fragen und Antworten_ diff --git a/src/content/translations/de/decentralized-identity/index.md b/src/content/translations/de/decentralized-identity/index.md index c79623b878d..596d3fa22ce 100644 --- a/src/content/translations/de/decentralized-identity/index.md +++ b/src/content/translations/de/decentralized-identity/index.md @@ -157,6 +157,7 @@ Es gibt viele ehrgeizige Projekte, die Ethereum als Grundlage für dezentrale Id - **[Ethereum Name Service (ENS)](https://ens.domains/)** - _Ein dezentralisiertes Namenssystem für maschinenlesbare On-chain-Identifikatoren, wie Ethereum Wallet-Adressen, Content-Hashes und Metadaten._ - **[SpruceID](https://www.spruceid.com/)** - _Ein dezentralisiertes Identitätsprojekt, das es Benutzern erlaubt, digitale Identitäten mit Hilfe von Ethereum-Konten und ENS-Profilen zu kontrollieren, statt sich auf Dienste Dritter zu verlassen._ +- **[Ethereum Attestation Service (EAS)](https://attest.sh/)** - _Ein dezentralisiertes Ledger/Protokoll zum Erstellen von On-Ketten- oder Off-Kettenbescheinigungen über irgendetwas._ - **[Proof of Humanity](https://www.proofofhumanity.id)** - _Proof of Humanity (Beweis des Menschseins) ist ein auf Ethereum basierendes System zur Überprüfung der sozialen Identität._ - **[BrightID](https://www.brightid.org/)**- _Ein dezentralisiertes quelloffenes Netzwerk zur sozialen Identität, das versucht, die Identitätsüberprüfung durch die Schaffung und Analyse eines sozialen Diagramms zu reformieren._ - **[Personennachweis-Passport](https://proofofpersonhood.com/)** - _Ein dezentraler digitaler Identitätsaggregator._ diff --git a/src/content/translations/de/desci/index.md b/src/content/translations/de/desci/index.md index 89d7734bc3f..17704fe8ae5 100644 --- a/src/content/translations/de/desci/index.md +++ b/src/content/translations/de/desci/index.md @@ -20,9 +20,9 @@ DeSci zielt darauf ab, ein Ökosystem zu schaffen, in dem Wissenschaftler ermuti Dezentralisierte Wissenschaft ermöglicht eine Vielzahl von Finanzierungsmöglichkeiten (von [DAOs](/dao/), [quadratischen Spenden](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531) bis hin zu Crowdfunding und mehr), einen leichteren Zugang zu Daten und Methoden sowie Anreize für Reproduzierbarkeit. -### Juan Benet - DeSci, unabhängige Labore und datenintensive Wissenschaft im großen Maßstab +### Juan Benet - Die DeSci-Bewegung - + ## Wie DeSci die Wissenschaft verbessert {#desci-improves-science} @@ -108,7 +108,6 @@ Erkunden Sie Projekte und werden Sie Teil der DeSci-Gemeinschaft. - [VitaDAO: Langfristige Forschung finanziert durch gesponserte Forschungsverträge](https://www.vitadao.com/) - [Flamming-Protokoll: Open-Source-Datenwirtschaft, die die kollaborative biomedizinische Entdeckung fördert](https://medium.com/@FlemingProtocol/a-data-economy-for-patient-driven-biomedical-innovation-9d56bf63d3dd) - [Aktives Inferenz-Labor](https://www.activeinference.org/) -- [Cherubs DAO: NFT finanzierte und DAO regelte Impact Fonds für psychische Gesundheit & Gehirn-Wellness](https://cherubsdao.com/) - [CureDAO: Community-eigene Gesundheitsplattform](https://docs.curedao.org/) - [IdeaMarkets: Ermöglicht dezentralisierte wissenschaftliche Glaubwürdigkeit](https://ideamarket.io/) @@ -135,5 +134,5 @@ Wir freuen uns über Vorschläge für neue Projekte, die in die Liste aufgenomme - [Was ist die dezentralisierte Wissenschaft?](https://www.youtube.com/watch?v=-DeMklVWNdA) - [Gespräch zwischen Vitalik Buterin und dem Wissenschaftler Aubrey de Grey über den Schnittpunkt der Langlebigkeitsforschung und Kryptographie](https://www.youtube.com/watch?v=x9TSJK1widA) - [Wissenschaftliche Veröffentlichung ist kaputt. Kann Web3 das reparieren?](https://www.youtube.com/watch?v=WkvzYgCvWj8) -- [Juan Benet - DeSci, Independent Labs, & groß angelegte Datenwissenschaft](https://www.youtube.com/watch?v=zkXM9H90g_E) +- [Juan Benet - DeSci, unabhängige Labore und datenintensive Wissenschaft im großen Maßstab](https://www.youtube.com/watch?v=zkXM9H90g_E) - [Sebastian Brunemeier – Wie DeSci die biomedizinische Forschung verändern kann & Risikokapital](https://www.youtube.com/watch?v=qB4Tc3FcVbM) diff --git a/src/content/translations/de/nft/index.md b/src/content/translations/de/nft/index.md index 3fbc7f70ffb..c30537b76bf 100644 --- a/src/content/translations/de/nft/index.md +++ b/src/content/translations/de/nft/index.md @@ -345,11 +345,12 @@ Die meisten NFTs werden mit dem einheitlichen Standard [ERC-721](/developers/doc ## Weiterführende Informationen {#further-reading} -- [Daten zu Krypto art-Kunst](https://cryptoart.io/data) – Richard Chen, automatisch aktualisiert +- [Daten zu Krypto art-Kunst](https://cryptoart.io/data) – _Richard Chen, automatisch aktualisiert_ - [OpenSea: OpenSea: die NFT-Bibel](https://opensea.io/blog/guides/non-fungible-tokens/) – _Devin Fizner, 10. Januar 2020_ - [NFT-Leitfaden für Einsteiger](https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d) – _Linda Xie, Januar 2020_ - [Alles, was Sie über das Metaverse wissen müssen](https://foundation.app/blog/enter-the-metaverse) – _Foundation-Team, foundation.app_ - [Nein, Krypto-Künstler schaden dem Planeten nicht](https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61) - [Der Energieverbrauch von Ethereum](/energy-consumption/) +- [Ethereum NFT APIs](https://www.alchemy.com/list-of/nft-apis-on-ethereum) - _Alchemy_ diff --git a/src/content/translations/es/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md b/src/content/translations/es/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md index 4406420880c..8393286cd1e 100644 --- a/src/content/translations/es/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md +++ b/src/content/translations/es/developers/tutorials/a-developers-guide-to-ethereum-part-one/index.md @@ -84,7 +84,7 @@ En este tutorial, trabajaremos solo con el intérprete de Python. No crearemos n
Nota: en los ejemplos de abajo, los comandos que empiezan con `$` están destinados a ser ejecutados en la terminal. (No escriba el símbolo `$`, ya que sólo significa el inicio de la línea).
-Primero, instale [IPython](https://ipython.org/) para tener un entorno fácil de usar para explorar. IPython ofrece el autocompletado de pestañas —entre otras características—, haciendo mucho más fácil ver qué es posible con Web3.py. +Primero, instale [IPython](https://ipython.org/) para tener un entorno fácil de usar para explorar. IPython ofrece el autocompletado mediante la tecla de tabulación —entre otras características—, haciendo mucho más fácil ver qué es posible con Web3.py. ```bash pip install ipython diff --git a/src/content/translations/fr/community/online/index.md b/src/content/translations/fr/community/online/index.md index 43d35c9c9b7..d74e2e01d78 100644 --- a/src/content/translations/fr/community/online/index.md +++ b/src/content/translations/fr/community/online/index.md @@ -26,9 +26,9 @@ Des centaines de milliers de passionnés d'Ethereum se rassemblent sur ces forum CryptoDevs - Communauté Discord axée sur le développement Ethereum Discord EthStaker - Communauté orientée autour de l'offre de soutien à la gestion de projet concernant le développement d'Ethereum Équipe du site web Ethereum.org - consultez et discutez du développement et du design du site web ethereum.org avec l'équipe et les membres de la communauté -Discord Matos - Communauté de créateurs Web3 où les bâtisseurs, les chefs de file industriels et les enthousiastes d'Ethereum se rencontrent. Nous sommes passionnés par le développement du Web3, sa conception et sa culture. Venez le bâtir avec nous. -Solidity Gitter - Forum de discussion pour le développement en Solidity (Gitter) -Solidity Matrix - Forum de discussion pour le développement en Solidity (Matrix) +Discord Matos - Communauté de créateurs Web3 où les bâtisseurs, les chefs de file industriels et les passionnés d'Ethereum se rencontrent. Nous sommes passionnés par le développement du Web3, sa conception et sa culture. Venez le bâtir avec nous. +Solidity Gitter - forum de discussion pour le développement Solidity (Gitter) +Solidity Matrix - forum de discussion pour le développement Solidity (Matrix) Ethereum Stack Exchange _- forum de questions-réponses_ Peeranha _- forum de questions-réponses décentralisé_ diff --git a/src/content/translations/fr/community/support/index.md b/src/content/translations/fr/community/support/index.md index 6e7f730db91..99f32b16507 100644 --- a/src/content/translations/fr/community/support/index.md +++ b/src/content/translations/fr/community/support/index.md @@ -38,6 +38,7 @@ Vous êtes à la recherche d'un portefeuille Ethereum ? [Explorez notre liste co Le développement d'une application décentralisée peut être difficile. Voici quelques espaces axés sur leur création, avec des développeurs Ethereum chevronnés qui seront heureux de vous faire part de leur expérience. +- [Alchemy University](https://university.alchemy.com/#starter_code) - [Discord CryptoDevs](https://discord.gg/Z9TA39m8Yu) - [StackExchange Ethereum](https://ethereum.stackexchange.com/) - [StackOverflow](https://stackoverflow.com/questions/tagged/web3) diff --git a/src/content/translations/fr/desci/index.md b/src/content/translations/fr/desci/index.md index 2ebee4ad99b..81e434e76ab 100644 --- a/src/content/translations/fr/desci/index.md +++ b/src/content/translations/fr/desci/index.md @@ -3,7 +3,7 @@ title: La science décentralisée (DeSci) description: Présentation de la science décentralisée sur Ethereum lang: fr template: use-cases -emoji: ":microscope :" +emoji: ":microscope:" sidebarDepth: 2 image: ../../../../assets/future_transparent.png alt: "" diff --git a/src/content/translations/fr/developers/docs/apis/backend/index.md b/src/content/translations/fr/developers/docs/apis/backend/index.md index 14d29aee242..96dfe9094f6 100644 --- a/src/content/translations/fr/developers/docs/apis/backend/index.md +++ b/src/content/translations/fr/developers/docs/apis/backend/index.md @@ -6,9 +6,9 @@ lang: fr Pour qu'une application logicielle puisse interagir avec la blockchain Ethereum (c'est-à-dire lire les données de la blockchain et/ou envoyer des transactions sur le réseau), elle doit se connecter à un nœud Ethereum. -Dans cet objectif, chaque client Ethereum implémente la spécification [JSON-RPC](/developers/docs/apis/json-rpc/) pour former un ensemble uniforme de [points de terminaison](/developers/docs/apis/json-rpc/#json-rpc-methods) sur lesquels les applications peuvent s'appuyer. +Dans cet objectif, chaque client Ethereum implémente la spécification [JSON-RPC](/developers/docs/apis/json-rpc/) pour former un ensemble uniforme de [méthodes](/developers/docs/apis/json-rpc/#json-rpc-methods) sur lesquelles les applications peuvent s'appuyer. -Si vous souhaitez utiliser un langage de programmation spécifique pour vous connecter à un nœud Ethereum, vous pouvez développer votre propre solution, mais il existe plusieurs bibliothèques pratiques au sein de l'écosystème qui facilitent grandement cette tâche. Avec ces bibliothèques, les développeurs peuvent rédiger des méthodes intuitives d'une seule ligne pour initialiser les demandes JSON-RPC (pas directement visibles) qui interagissent avec Ethereum. +Si vous souhaitez utiliser un langage de programmation spécifique pour vous connecter à un nœud Ethereum, vous pouvez développer votre propre solution, mais il existe plusieurs bibliothèques pratiques au sein de l'écosystème qui facilitent grandement cette tâche. Grâce à ces bibliothèques, les développeurs peuvent rédiger des méthodes intuitives d'une seule ligne pour initialiser des demandes RPC JSON (sous le capot) qui interagissent avec Ethereum. ## Prérequis {#prerequisites} @@ -16,7 +16,7 @@ Il peut être utile de comprendre en quoi consiste la [pile Ethereum](/developer ## Pourquoi utiliser une bibliothèque ? {#why-use-a-library} -Ces bibliothèques suppriment une grande partie de la complexité d'une interaction directe avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex. convertir des ETH en gwei) afin que vous puissiez, en tant que développeur, passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous consacrer aux fonctionnalités uniques de votre application. +Les bibliothèques suppriment une grande partie de la complexité de l'interaction directe avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex. convertir des ETH en gwei) afin que vous puissiez, en tant que développeur, passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous consacrer aux fonctionnalités uniques de votre application. ## Bibliothèques disponibles {#available-libraries} @@ -32,6 +32,12 @@ Ces bibliothèques suppriment une grande partie de la complexité d'une interact - [blockcypher.com](https://www.blockcypher.com/) - [Documentation](https://www.blockcypher.com/dev/ethereum/) +**Blast by Bware Labs-** **_ API décentralisées pour le réseau principal et les réseaux de tests Ethereum._** + +- [blastapi.io](https://blastapi.io/) +- [Documentation](https://docs.blastapi.io) +- [Discord](https://discord.com/invite/VPkWESgtvV) + **Infura -** **_L'API Ethereum en tant que service_** - [infura.io](https://infura.io) @@ -42,12 +48,24 @@ Ces bibliothèques suppriment une grande partie de la complexité d'une interact - [cloudflare-eth.com](https://cloudflare-eth.com) +**Nœud Cloud Coinbase -** **_API d'infrastructure blockchain._** + +- [Nœud cloud de Coinbase](https://www.coinbase.com/cloud/products/node) +- [Documentation](https://docs.cloud.coinbase.com/node/reference/welcome-to-node) + **DataHub by Figment -** **_Services API Web3 avec réseau principal et réseaux de tests Ethereum._** - [DataHub](https://www.figment.io/datahub) - [Documentation](https://docs.figment.io/introduction/what-is-datahub) -**Nodesmith -** **_Accès API JSON-RPC API au réseau principal et aux réseaux tests Ethereum._** +**NFTPort -** **_API de frappe et de données Ethereum._** + +- [nftport.xyz](https://www.nftport.xyz/) +- [Documentation](https://docs.nftport.xyz/) +- [GitHub](https://github.com/nftport/) +- [Discord](https://discord.com/invite/K8nNrEgqhE) + +**Podestat -** **_Accès API JSON-RPC au réseau principal et aux réseaux tests Ethereum._** - [nodesmith.io](https://nodesmith.io/network/ethereum/) - [Documentation](https://nodesmith.io/docs/#/ethereum/apiRef) @@ -60,8 +78,9 @@ Ces bibliothèques suppriment une grande partie de la complexité d'une interact - [chainstack.com](https://chainstack.com) - [Documentation](https://docs.chainstack.com) +- [Référence de l'API Ethereum](https://docs.chainstack.com/api/ethereum/ethereum-api-reference) -**QuikNode -** **_Infrastructure Blockchain en tant que service_** +**Quinone -** **_Infrastructure Blockchain en tant que service_** - [quicknode.com](https://quicknode.com) - [Documentation](https://www.quicknode.com/docs) @@ -70,8 +89,8 @@ Ces bibliothèques suppriment une grande partie de la complexité d'une interact **Python Tooling -** **_Diverses bibliothèques pour interagir avec Ethereum via Python_** - [py.ethereum.org](http://python.ethereum.org/) -- [GitHub web3.py](https://github.com/ethereum/web3.py) -- [Chat web3.py](https://gitter.im/ethereum/web3.py) +- [GitHub Web3.py](https://github.com/ethereum/web3.py) +- [Chat Web3.py](https://gitter.im/ethereum/web3.py) **web3j -** **_Bibliothèque d'intégration Java/Android/Kotlin/Scala pour Ethereum_** @@ -111,6 +130,24 @@ Ces bibliothèques suppriment une grande partie de la complexité d'une interact - [Documentation](https://docs.zmok.io/) - [Discord](https://discord.gg/fAHeh3ka6s) +**NOWNodes - _Explorateurs de nœuds complets et de blocs._** + +- [NOWNodes.io](https://nownodes.io/) +- [Documentation](https://documenter.getpostman.com/view/13630829/TVmFkLwy#intro) + +**Moralis -** **_Fournisseur d'API EVM de niveau entreprise._** + +- [moralis.io](http://moralis.io) +- [Documentation](https://docs.moralis.io/) +- [GitHub](https://github.com/MoralisWeb3) +- [Discord](https://discord.com/invite/KYswaxwEtg) +- [Forum](https://forum.moralis.io/) + +**GetBlock - _Blockchain-as-a-service pour le développement Web3_** + +- [GetBlock.io](https://getblock.io/) +- [Documentation](https://getblock.io/docs/) + ## Complément d'information {#further-reading} _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ diff --git a/src/content/translations/fr/developers/docs/apis/javascript/index.md b/src/content/translations/fr/developers/docs/apis/javascript/index.md index 4595a8cb707..49af366e5bd 100644 --- a/src/content/translations/fr/developers/docs/apis/javascript/index.md +++ b/src/content/translations/fr/developers/docs/apis/javascript/index.md @@ -1,15 +1,17 @@ --- title: Bibliothèques d'API JavaScript -description: Introduction aux Api clientes Ethereum, qui vous permettent d'interagir avec la blockchain depuis votre application. +description: Introduction aux bibliothèques clientes JavaScript, qui vous permettent d'interagir avec la blockchain depuis votre application. lang: fr --- Pour qu'une application Web puisse interagir avec la blockchain Ethereum (c'est-à-dire lire les données de la blockchain et/ou envoyer des transactions sur le réseau), elle doit se connecter à un nœud Ethereum. -Dans cet objectif, chaque client Ethereum implémente la spécification [JSON-RPC](/developers/docs/apis/json-rpc/) pour former un ensemble uniforme de [points de terminaison](/developers/docs/apis/json-rpc/endpoints/) sur lesquels les applications peuvent s'appuyer. +Dans cet objectif, chaque client Ethereum implémente la spécification [JSON-RPC](/developers/docs/apis/json-rpc/) pour former un ensemble uniforme de [méthodes](/developers/docs/apis/json-rpc/#json-rpc-methods) sur lesquelles les applications peuvent s'appuyer. Si vous voulez utiliser JavaScript pour vous connecter à un nœud Ethereum, il est possible d'avoir recours à Vanilla JavaScript, mais plusieurs bibliothèques de commodité existent à l'intérieur même de l'écosystème, ce qui rend les choses beaucoup plus simples. Avec ces bibliothèques, les développeurs peuvent rédiger des méthodes intuitives d'une seule ligne pour initialiser les demandes JSON RPC (pas directement visibles) qui interagissent avec Ethereum. +Veuillez noter que depuis [La Fusion](/roadmap/merge/), deux parties de logiciels Ethereum connectés - un client d'exécution et un client de consensus - sont nécessaires pour exécuter un nœud. Veuillez vous assurer que votre nœud inclut à la fois un client d'exécution et un client de consensus. Si votre nœud n'est pas sur votre machine en local (par ex. votre nœud est exécuté sur une instance AWS), mettez à jour les adresses IP dans le tutoriel en conséquence. Pour plus d'informations, veuillez consulter notre page sur [l'exécution d'un noeud](/developers/docs/nodes-and-clients/run-a-node/). + ## Prérequis {#prerequisites} Il peut être utile de comprendre non seulement en quoi consiste JavaScript, mais aussi la [pile Ethereum](/developers/docs/ethereum-stack/) et les [clients Ethereum](/developers/docs/nodes-and-clients/). @@ -22,17 +24,17 @@ Ces bibliothèques suppriment une grande partie de la complexité d'une interact ### Se connecter à des nœud Ethereum {#connect-to-ethereum-nodes} -En utilisant des fournisseurs, les bibliothèques vous permettent de vous connecter à Ethereum et de lire ses données, que ce soit sur JSON-RPC, INFURA, Etherscan, Alchemy ou MetaMask. +En utilisant des fournisseurs, les bibliothèques vous permettent de vous connecter à Ethereum et de lire ses données, que ce soit sur JSON-RPC, INFURA, Etherscan, Alchemy ou Metamask. **Exemple Ether** ```js -// Un Web3Provider enveloppe un fournisseur Web3 standard, qui est -// ce que MetaMask injecte comme window.ethereum dans chaque page. +// A Web3Provider wraps a standard Web3 provider, which is +// what MetaMask injects as window.ethereum into each page const provider = new ethers.providers.Web3Provider(window.ethereum) -// Le plugin MetaMask permet également de signer des transactions pour -// envoyer de l'ether et payer pour changer l'état de la blockchain. +// The MetaMask plugin also allows signing transactions to +// send ether and pay to change state within the blockchain. // Pour cela, nous avons besoin du signataire du compte... const signer = provider.getSigner() ``` @@ -66,13 +68,13 @@ Une fois la configuration effectuée, vous pourrez interroger la blockchain pour - le gaz estimé ; - les événements du contract intelligent ; - l'ID du réseau ; -- Et plus encore... +- et plus encore... ### Fonctionnalités d'un portefeuille {#wallet-functionality} Les bibliothèques vous permettent de créer des portefeuilles, gérer vos clés et signer des transactions. -Voici un exemple provenant de la bibliothèque Ethers : +Voici un exemple provenant de la bibliothèque Ethers ```js // Créer une instance de portefeuille à partir d'un mnémonique... @@ -151,7 +153,7 @@ Une fois la configuration effectuée, vous pourrez : ### Interagir avec les fonctions d'un contrat intelligent {#interact-with-smart-contract-functions} -Les bibliothèques clientes JavaScript autorisent votre application à appeler des fonctions de contrat intelligent en lisant l'interface binaire-programme (ABI) d'un contrat compilé. +Les bibliothèques clientes JavaScript autorisent votre application à appeler des fonctions de contrat intelligent en lisant l'interface binaire d'application (ABI) d'un contrat compilé. L'ABI explique principalement les fonctions du contrat au format JSON et vous permet de l'utiliser comme un objet JavaScript standard. @@ -217,7 +219,7 @@ Les fonctions utilitaires vous offrent des raccourcis pour améliorer le dévelo Les valeurs ETH sont en wei par défaut. 1 ETH = 1 000 000 000 000 000 000 WEI – ça en fait, des chiffres à gérer ! `web3.utils.toWei` convertit l'ether en wei pour vous. -Et dans l'Ethers cela ressemble à ce qui suit : +Et en ethers, cela ressemble à ce qui suit : ```js // Obtenir le solde d'un compte (par l'adresse ou le nom ENS) @@ -272,14 +274,19 @@ ethers.utils.formatEther(balance) - [Documentation](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api) - [GitHub](https://github.com/alchemyplatform/alchemy-web3) +**viem -** **_Interface TypeScript pour Ethereum._** + +- [Documentation](https://viem.sh) +- [Github](https://github.com/wagmi-dev/viem) + ## Complément d'information {#further-reading} _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ -## Thèmes connexes {#related-topics} +## Sujets connexes {#related-topics} - [Nœuds et clients](/developers/docs/nodes-and-clients/) -- [Infrastructures de développement](/developers/docs/frameworks/) +- [Frameworks de développement](/developers/docs/frameworks/) ## Tutoriels connexes {#related-tutorials} diff --git a/src/content/translations/fr/developers/docs/apis/json-rpc/index.md b/src/content/translations/fr/developers/docs/apis/json-rpc/index.md index 2bf9ba13674..39c2a37d5df 100644 --- a/src/content/translations/fr/developers/docs/apis/json-rpc/index.md +++ b/src/content/translations/fr/developers/docs/apis/json-rpc/index.md @@ -4,27 +4,2379 @@ description: Un protocole allégé de procédure à distance (RPC) pour les clie lang: fr --- -Afin qu'une application logicielle interagisse avec la blockchain Ethereum (en lisant les données de la blockchain et/ou en envoyant des transactions au réseau), il doit se connecter à un nœud Ethereum. +Afin qu'une application logicielle interagisse avec la blockchain Ethereum (en lisant les données de la blockchain ou en envoyant des transactions au réseau), elle doit se connecter à un nœud Ethereum. -À cet effet, chaque client [Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implémente une spécification [JSON-RPC](http://www.jsonrpc.org/specification), ainsi il existe un ensemble uniforme de méthodes sur lesquelles les applications peuvent compter. +À cet effet, chaque [client Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implémente une [spécification JSON-RPC](https://github.com/ethereum/execution-apis), ainsi il existe un ensemble uniforme de méthodes sur lesquelles les applications peuvent s'appuyer en fonction des spécificités du nœud ou de l'implémentation client. -JSON-PRC est un protocole allégé de procédure à distance (RPC). En premier lieu, la spécification définit plusieurs structures de données et les règles autour de leur traitement. C'est un système de transport agnostique en ce sens que les concepts peuvent être utilisés dans le même processus, via les sockets et HTTP, ou dans de nombreux environnements de passage de messages. Il utilise JSON (RFC 4627) comme format de données. - -## Ressources JSON-RPC {#json-rpc-resources} - -- [Spécification Ethereum JSON-RPC](https://playground.open-rpc.org/?schemaUrl=https://raw.githubusercontent.com/ethereum/eth1.0-apis/assembled-spec/openrpc.json&uiSchema[appBar][ui:splitView]=true&uiSchema[appBar][ui:input]=false&uiSchema[appBar][ui:examplesDropdown]=false) -- [Dépôt GitHub de la spécification Ethereum JSON-RPC](https://github.com/ethereum/eth1.0-apis) +[JSON-RPC](https://www.jsonrpc.org/specification) est un protocole léger de procédure d'appel à distance (RPC). Il définit plusieurs structures de données et les règles entourant leur traitement. C'est un système de transport agnostique en ce sens que les concepts peuvent être utilisés dans le même processus, via les sockets et HTTP, ou dans de nombreux environnements de passage de messages. Il utilise JSON (RFC 4627) comme format de données. ## Implémentations de client {#client-implementations} Les clients Ethereum peuvent chacun utiliser différents langages de programmation lors de l'implémentation de la spécification JSON-RPC. Consultez la documentation individuelle [client](/developers/docs/nodes-and-clients/#execution-clients) pour plus de détails concernant des langages de programmation spécifiques. Nous vous recommandons de consulter la documentation de chaque client pour connaître les dernières informations de support de l'API. -## Librairies pratiques {#convenience-libraries} +## Bibliothèques pratiques {#convenience-libraries} Bien que vous puissiez choisir d'interagir directement avec les clients Ethereum via l'API JSON-RPC, il y a souvent des options plus faciles pour les développeurs de dapp. De nombreuses librairies [JavaScript](/developers/docs/apis/javascript/#available-libraries) et [backend API](/developers/docs/apis/backend/#available-libraries) existent pour fournir des wrappers sur l'API JSON-RPC. Avec ces bibliothèques, les développeurs peuvent écrire de manières intuitives des méthodes d'une seule ligne pour initialiser les requêtes JSON-RPC (sans avoir besoin d'en voir les détails) qui interagissent avec Ethereum. +## API client de consensus {#consensus-clients} + +Cette page traite principalement de l'API JSON-RPC utilisée par les clients d'exécution Ethereum. Cependant, les clients de consensus ont également une API RPC qui permet aux utilisateurs de interroger des informations sur le nœud, demander des blocs de balises, l'état de la balise et d'autres informations liées au consensus directement depuis un nœud. Cette API est documentée sur la [page Web de l'API de la chaîne phare](https://ethereum.github.io/beacon-APIs/#/). + +Une API interne est également utilisée pour la communication entre les clients dans un noeud - c'est-à-dire permet au client de consensus et au client d'exécution d'échanger des données. Cela s'appelle une « API moteur » et les spécifications sont disponibles sur [GitHub](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). + +## Spécifications de client d'exécution {#spec} + +[Lisez la spécification complète de l'API JSON-RPC sur GitHub](https://github.com/ethereum/execution-apis). + +## Conventions {#conventions} + +### Encodage hexadécimal {#hex-encoding} + +Deux types de données clés sont passés par JSON : des tableaux d'octets non formatés et des quantités. Les deux sont passés avec un encodage hexadécimal mais avec des formatages différents. + +#### Quantités {#quantities-encoding} + +Lors de l'encodage des quantités (entiers, chiffres) : encoder en hexadécimal, préfixer avec « 0x », la représentation la plus compacte (légère exception : zéro doit être représenté par « 0x0 »). + +Voici quelques exemples : + +- 0x41 (65 en décimal) +- 0x400 (1024 en décimal) +- FAUX : 0x (devrait toujours avoir au moins un chiffre - zéro est « 0x0 ») +- FAUX : 0x0400 (pas de zéros autorisés en premier) +- FAUX : ff (doit être préfixé par 0x) + +### Données non formatées {#unformatted-data-encoding} + +Lors de l'encodage de données non formatées (tableaux d'octets, adresses de compte, hachages, tableaux de bytecode) : encoder en hex, préfixer avec « 0x », deux chiffres hexadécimaux par octet. + +Voici quelques exemples : + +- 0x41 (taille 1, « A ») +- 0x004200 (taille 3, « \0B\0 ») +- 0x (taille 0, "") +- FAUX : 0xf0f0f (doit avoir un nombre pair de chiffres) +- FAUX : 004200 (doit être préfixé par 0x) + +### Le paramètre de bloc par défaut {#default-block} + +Les méthodes suivantes ont un paramètre de bloc par défaut supplémentaire : + +- [eth_getBalance](#eth_getbalance) +- [eth_getCode](#eth_getcode) +- [eth_getTransactionCount](#eth_gettransactioncount) +- [eth_getStorageAt](#eth_getstorageat) +- [eth_call](#eth_call) + +Lorsque des requêtes qui agissent sur l'état d'Ethereum sont exécutées, le dernier paramètre de bloc par défaut détermine la hauteur du bloc. + +Les options suivantes sont possibles pour le paramètre defaultBlock : + +- `chaîne HEX` - un nombre de bloc entier +- `Chaîne « earliest »` pour le bloc d'origine/le plus ancien +- `Chaine « latest »` - pour le dernier bloc miné +- `Chaine « latest »` - pour le dernier bloc de tête sûr +- `Chaîne « finalized »` - pour le dernier bloc finalisé +- `Chaîne "pending"` - pour l'état ou les transactions en attente + +## Exemples + +Sur cette page, nous fournissons des exemples d'utilisation des points de terminaison individuels de l'API JSON_RPC à l'aide de l'outil de ligne de commande, [curl](https://curl.se). Ces exemples de points de terminaison individuels se trouvent ci-dessous dans la section [Exemples Curl](#curl-examples). Plus bas sur la page, nous fournissons également un [exemple de bout en bout](#usage-example) pour compiler et déployer un contrat intelligent à l'aide d'un nœud Geth, de l'API JSON_RPC et de curl. + +## Exemples de Curl {#curl-examples} + +Des exemples d'utilisation de l'API JSON_RPC en effectuant des requêtes [curl](https://curl.se) vers un nœud Ethereum sont fournis ci-dessous. Chaque exemple comprend une description du point de terminaison spécifique, de ses paramètres, du type de retour et un exemple concret de son utilisation. + +Les requêtes curl peuvent retourner un message d'erreur relatif au type de contenu. Ceci est dû au fait que l'option `--data` définit le type de contenu à `application/x-www-form-urlencoded`. Si votre nœud se plaint à ce sujet, définissez manuellement l'en-tête en plaçant `-H "Content-Type: application/json"` au début de l'appel. Les exemples ne comprennent pas non plus la combinaison URL/IP & port qui doit être le dernier argument donné à curl ( par exemple : `127.0.0.1:8545`). Une requête curl complète incluant ces données supplémentaires prend la forme suivante : + +```shell +curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":67}' 127.0.0.1:8545 +``` + +## Gossip, État, Historique {#gossip-state-history} + +Une poignée de méthodes JSON-RPC de base nécessitent des données du réseau Ethereum, et se classent aisément dans 3 catégories principales : _Gossip, État, Historique_. Utilisez les liens dans ces sections pour passer à chaque méthode, ou utilisez la table des matières pour explorer la liste complète des méthodes. + +### Méthodes Gossip {#gossip-methods} + +> Ces méthodes permettent de suivre la tête de la chaîne. C'est ainsi que les transactions font leur chemin à travers le réseau, qu'elles se retrouvent dans des blocs et que les clients découvrent les nouveaux blocs. + +- [eth_blockNumber](#eth_blocknumber) +- [eth_sendRawTransaction](#eth_sendrawtransaction) + +### Méthodes d'état {#state_methods} + +> Méthodes qui rapportent l'état actuel de toutes les données stockées. L' « état » est comme un grand morceau partagé de RAM, et comprend les soldes des comptes, les données des contrats et les estimations de gaz. + +- [eth_getBalance](#eth_getbalance) +- [eth_getStorageAt](#eth_getstorageat) +- [eth_getTransactionCount](#eth_gettransactioncount) +- [eth_getCode](#eth_getcode) +- [eth_call](#eth_call) +- [eth_estimateGas](#eth_estimategas) + +### Méthodes d'historique {#history_methods} + +> Récupère les enregistrements historiques de chaque bloc depuis la genèse. Il s'agit d'un grand fichier à usage unique, qui comprend l'ensemble des en-têtes de bloc, des corps de blocs, des blocs d'oncle et les reçus de transaction. + +- [eth_getBlockTransactionCountByHash](#eth_getblocktransactioncountbyhash) +- [eth_getBlockTransactionCountByNumber](#eth_getblocktransactioncountbynumber) +- [eth_getUncleCountByBlockHash](#eth_getunclecountbyblockhash) +- [eth_getUncleCountByBlockNumber](#eth_getunclecountbyblocknumber) +- [eth_getBlockByHash](#eth_getblockbyhash) +- [eth_getBlockByNumber](#eth_getblockbynumber) +- [eth_getTransactionByHash](#eth_gettransactionbyhash) +- [eth_getTransactionByBlockHashAndIndex](#eth_gettransactionbyblockhashandindex) +- [eth_getTransactionByBlockNumberAndIndex](#eth_gettransactionbyblocknumberandindex) +- [eth_getTransactionReceipt](#eth_gettransactionreceipt) +- [eth_getUncleByBlockHashAndIndex](#eth_getunclebyblockhashandindex) +- [eth_getUncleByBlockNumberAndIndex](#eth_getunclebyblocknumberandindex) + +## Méthodes API JSON-RPC {#json-rpc-methods} + +### web3_clientVersion {#web3_clientversion} + +Retourne la version courante du client. + +**Paramètres** + +Aucun + +**Valeur de retour** + +`String` - La version actuelle du client + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc":"2.0", + "result": "Mist/v0.9.3/darwin/go1.4.1" +} +``` + +### web3_sha3 {#web3_sha3} + +Retourne le Keccak-256 (_non pas_ le SHA3-256 standard) des données. + +**Paramètres** + +1. `DATA` - les données à convertir en hachage SHA3 + +```js +params: ["0x68656c6c6f20776f726c64"] +``` + +**Valeur de retour** + +`DATA` - Le résultat SHA3 pour la chaîne donnée. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"web3_sha3","params":["0x68656c6c6f20776f726c64"],"id":64}' +// Result +{ + "id":64, + "jsonrpc": "2.0", + "result": "0x47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad" +} +``` + +### net_version {#net_version} + +Retourne l'identifiant du réseau actuel. + +**Paramètres** + +Aucune + +**Retours** + +`String` - L'id actuelle du réseau. + +La liste complète des identifiants de réseau actuels est disponible à l'adresse suivante : [chainlist.org](https://chainlist.org). Quelques spécifications habituelles sont : + +- `1`: réseau principal Ethereum +- `5`: Réseau de test Goerli +- `11155111`: Réseau de test Sepolia + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"net_version","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "3" +} +``` + +### net_listening {#net_listening} + +Retourne `true` si le client écoute activement les connexions réseau. + +**Paramètres** + +Aucune + +**Retours** + +`Boolean` - `true` lors de l'écoute, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"net_listening","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc":"2.0", + "result":true +} +``` + +### net_peerCount {#net_peercount} + +Retourne le nombre de pairs actuellement connectés au client. + +**Paramètres** + +Aucune + +**Retours** + +`QUANTITY` - nombre entier du nombre de pairs connectés. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id":74}' +// Result +{ + "id":74, + "jsonrpc": "2.0", + "result": "0x2" // 2 +} +``` + +### eth_protocolVersion {#eth_protocolversion} + +Retourne la version actuelle du protocole Ethereum. Notez que cette méthode n'est [pas disponible dans Geth](https://github.com/ethereum/go-ethereum/pull/22064#issuecomment-788682924). + +**Paramètres** + +Aucune + +**Retours** + +`String` - La version actuelle du protocole Ethereum + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_protocolVersion","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "54" +} +``` + +### eth_syncing {#eth_syncing} + +Renvoie un objet contenant des données sur l'état de la synchronisation ou `false`. + +**Paramètres** + +Aucune + +**Retours** + +`Objet|Booléen`, un objet avec des données sur l'état de la synchronisation ou `FALSE`, s'il n'y a pas de synchronisation : + +- `startingBlock`: `QUANTITY` - Le bloc où l'importation a commencé (ne sera remis à zéro que lorsque la synchronisation aura atteint sa tête) +- `currentBlock`: `QUANTITY` - Le bloc actuel, identique à eth_blockNumber +- `highestBlock`: `QUANTITY` - Le bloc estimé le plus élevé + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": { + startingBlock: '0x384', + currentBlock: '0x386', + highestBlock: '0x454' + } +} +// Or when not syncing +{ + "id":1, + "jsonrpc": "2.0", + "result": false +} +``` + +### eth_coinbase {#eth_coinbase} + +Renvoie l'adresse coinbase du client. + +**Paramètres** + +Aucun + +**Retours** + +`DATA`, 20 octets - l'adresse actuelle de coinbase. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":64}' +// Result +{ + "id":64, + "jsonrpc": "2.0", + "result": "0x407d73d8a49eeb85d32cf465507dd71d507100c1" +} +``` + +## eth_chainId {#eth_chainId} + +Retourne la chaîne ID utilisée pour la signature d'opérations protégées par la rediffusion. + +**Paramètres** + +Aucune + +**Retours** + +`chainId`, valeur hexadécimale comme une chaîne représentant le nombre entier de l'id de la chaîne courante. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "0x1" +} +``` + +### eth_mining {#eth_mining} + +Retourne `true` si le client est en train de miner activement de nouveaux blocs. + +**Paramètres** + +Aucune + +**Retours** + +`Boolean` - renvoie `true` du client en train de miner, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_mining","params":[],"id":71}' +// +{ + "id":71, + "jsonrpc": "2.0", + "result": true +} +``` + +### eth_hashrate {#eth_hashrate} + +Retourne le nombre de hachages par seconde avec lesquels le nœud est miné. + +**Paramètres** + +Aucun + +**Retours** + +`QUANTITY` - nombre de hachages par seconde. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":71}' +// Result +{ + "id":71, + "jsonrpc": "2.0", + "result": "0x38a" +} +``` + +### eth_gasPrice {#eth_gasprice} + +Retourne le prix actuel de gaz en wei. + +**Paramètres** + +Aucun + +**Retours** + +`QUANTITY` - entier du prix actuel du gaz en wei. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}' +// Result +{ + "id":73, + "jsonrpc": "2.0", + "result": "0x1dfd14000" // 8049999872 Wei +} +``` + +### eth_accounts {#eth_accounts} + +Renvoie une liste d'adresses appartenant au client. + +**Paramètres** + +Aucun + +**Retours** + +`Array of DATA`, 20 octets - adresses appartenant au client. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"] +} +``` + +### eth_blockNumber {#eth_blocknumber} + +Renvoie le numéro du bloc le plus récent. + +**Paramètres** + +Aucune + +**Valeur de retour** + +`QUANTITY` - nombre entier du numéro de bloc actuel sur lequel se trouve le client. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":83}' +// Result +{ + "id":83, + "jsonrpc": "2.0", + "result": "0x4b7" // 1207 +} +``` + +### eth_getBalance {#eth_getbalance} + +Renvoie le solde du compte de l'adresse donnée. + +**Paramètres** + +1. `DATA`, 20 octets - adresse pour vérifier le solde. +2. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« latest »`, `« earliest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block) + +```js +params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"] +``` + +**Valeur de retour** + +`QUANTITY` - nombre entier du solde actuel en wei. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x0234c8a3397aab58" // 158972490234375000 +} +``` + +### eth_getStorageAt {#eth_getstorageat} + +Renvoie la valeur d'une position de stockage à une adresse donnée. + +**Paramètres** + +1. `DATA`, 20 octets - adresse du stockage. +2. `QUANTITY` - nombre entier de la position dans le stockage. +3. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« latest »`, `« earliest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block) + +**Valeur de retour** + +`DATA` - la valeur à cette position de stockage. + +**Exemple** Le calcul de la position correcte dépend du stockage à récupérer. Considérons le contrat suivant déployé à `0x295a70b2de5e3953354a6a8344e616ed314d7251` par l'adresse `0x391694e7e0b0cce554cb130d723a9d27458f9298`. + +``` +contract Storage { + uint pos0; + mapping(address => uint) pos1; + function Storage() { + pos0 = 1234; + pos1[msg.sender] = 5678; + } +} +``` + +La récupération de la valeur pos0 est simple : + +```js +curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545 +{"jsonrpc":"2.0","id":1,"result":"0x00000000000000000000000000000000000000000000000000000000000004d2"} +``` + +La récupération d'un élément de la carte est plus difficile. La position d'un élément dans la carte est calculée avec : + +```js +keccack(LeftPad32(key, 0), LeftPad32(map position, 0)) +``` + +Cela signifie que pour récupérer le stockage sur pos1["0x391694e7e0b0cce554cb130d723a9d27458f9298"] nous devons calculer la position avec : + +```js +keccak( + decodeHex( + "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + + "0000000000000000000000000000000000000000000000000000000000000001" + ) +) +``` + +La console geth qui est fournie avec la bibliothèque web3 peut être utilisée pour effectuer le calcul : + +```js +> var key = "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001" +undefined +> web3.sha3(key, {"encoding": "hex"}) +"0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9" +``` + +Maintenant, il faut aller chercher le stockage : + +```js +curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"], "id": 1}' localhost:8545 +{"jsonrpc":"2.0","id":1,"result":"0x000000000000000000000000000000000000000000000000000000000000162e"} +``` + +### eth_getTransactionCount {#eth_gettransactioncount} + +Renvoie le nombre de transactions _envoyées_ à partir d'une adresse. + +**Paramètres** + +1. `DATA`, 20 octets - adresse. +2. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« latest »`, `« earliest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block) + +```js +params: [ + "0x407d73d8a49eeb85d32cf465507dd71d507100c1", + "latest", // state at the latest block +] +``` + +**Valeur de retour** + +`QUANTITY` - nombre entier du nombre de transactions envoyées depuis cette adresse. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params":["0x407d73d8a49eeb85d32cf465507dd71d507100c1","latest"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x1" // 1 +} +``` + +### eth_getBlockTransactionCountByHash {#eth_getblocktransactioncountbyhash} + +Renvoie le nombre de transactions dans un bloc à partir d'un bloc correspondant au hachage de bloc donné. + +**Paramètres** + +1. `DATA`, 32 octets - hachage d'un bloc + +```js +params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] +``` + +**Valeur de retour** + +`QUANTITY` - nombre entier du nombre de transactions dans ce bloc. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHash","params":["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xb" // 11 +} +``` + +### eth_getBlockTransactionCountByNumber {#eth_getblocktransactioncountbynumber} + +Renvoie le nombre de transactions dans un bloc correspondant au numéro de bloc donné. + +**Paramètres** + +1. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« earliest »`, `« latest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block). + +```js +params: [ + "0xe8", // 232 +] +``` + +**Valeur de retour** + +`QUANTITY` - nombre entier du nombre de transactions dans ce bloc. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByNumber","params":["0xe8"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xa" // 10 +} +``` + +### eth_getUncleCountByBlockHash {#eth_getunclecountbyblockhash} + +Renvoie le nombre d'oncles dans un bloc à partir d'un bloc correspondant au hachage de bloc donné. + +**Paramètres** + +1. `DATA`, 32 octets - hachage d'un bloc + +```js +params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] +``` + +**Valeur de retour** + +`QUANTITY` - nombre entier du nombre d'oncles dans ce bloc. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","params":["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x1" // 1 +} +``` + +### eth_getUncleCountByBlockNumber {#eth_getunclecountbyblocknumber} + +Renvoie le nombre d'oncles dans un bloc à partir d'un bloc correspondant au numéro de bloc donné. + +**Paramètres** + +1. `QUANTITY|TAG` - nombre entier d'un bloc, ou la chaîne « latest », « earliest » ou « pending », voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block) + +```js +params: [ + "0xe8", // 232 +] +``` + +**Valeur de retour** + +`QUANTITY` - nombre entier du nombre d'oncles dans ce bloc. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockNumber","params":["0xe8"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x1" // 1 +} +``` + +### eth_getCode {#eth_getcode} + +Renvoie le code à une adresse donnée. + +**Paramètres** + +1. `DATA`, 20 octets - adresse +2. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« latest »`, `« earliest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block) + +```js +params: [ + "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", + "0x2", // 2 +] +``` + +**Valeur de retour** + +`DATA` - le code issu de l'adresse donnée. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCode","params":["0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b", "0x2"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x600160008035811a818181146012578301005b601b6001356025565b8060005260206000f25b600060078202905091905056" +} +``` + +### eth_sign {#eth_sign} + +La méthode du signe calcule une signature spécifique à Ethereum avec : `sign(keccak256("\x19Message signé Ethereum :\n" + len(message) + message)))`. + +En ajoutant un préfixe au message, la signature calculée peut être reconnue comme une signature spécifique à Ethereum. Cela empêche l'utilisation abusive où une dApp malveillant peut signer des données arbitraires (par exemple une transaction) et utiliser la signature pour usurper l'identité de la victime. + +Remarque : l'adresse avec laquelle signer doit être déverrouillée. + +**Paramètres** + +1. `DATA`, 20 octets - adresse +2. `DATA`, N octets - message à signer + +**Valeur de retour** + +`DATA` : Signature + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d370f73ec7d8a03e965129118dc8f5bf83", "0xdeadbeaf"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b" +} +``` + +### eth_signTransaction {#eth_signtransaction} + +Signale une transaction qui peut être soumise au réseau plus tard en utilisant [eth_sendRawTransaction](#eth_sendrawtransaction). + +**Paramètres** + +1. `Object` - L'objet de la transaction + +- `from`: `DATA`, 20 octets - L'adresse à partir de laquelle la transaction est envoyée. +- `to`: `DATA`, 20 octets - (optionnel lors de la création d'un nouveau contrat) L'adresse à laquelle la transaction est orientée. +- `gaz`: `QUANTITY` - (facultatif, par défaut : 90000) Nombre entier du gaz fourni pour l'exécution de la transaction. Il retournera du gaz inutilisé. +- `gasPrice` : `QUANTITY` - (facultatif, par défaut : To-Be-Determined) Nombre entier du prix du gaz utilisé pour chaque gaz payé, à Wei. +- `value`: `QUANTITY` - (facultatif) Nombre entier de la valeur envoyée avec cette transaction, dans Wei. +- `data`: `DATA` - Le code compilé d'un contrat OU le hachage de la signature de la méthode invoquée et des paramètres encodés. +- `nonce`: `QUANTITY` - (facultatif) Entier d'une nonce. Cela permet d'écraser vos propres transactions en attente qui utilisent la même nonce. + +**Valeur de retour** + +`DATA`, L'objet de la transaction signée. + +**Exemple** + +```js +// Request +curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction","params": [{"data":"0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675","from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155","gas": "0x76c0","gasPrice": "0x9184e72a000","to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567","value": "0x9184e72a"}]}' +// Result +{ + "id": 1, + "jsonrpc": "2.0", + "result": "0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b" +} +``` + +### eth_sendTransaction {#eth_sendtransaction} + +Crée une nouvelle transaction d'appel de message ou une création de contrat, si le champ de données contient du code. + +**Paramètres** + +1. `Object` - L'objet de la transaction + +- `from`: `DATA`, 20 octets - L'adresse à partir de laquelle la transaction est envoyée. +- `to`: `DATA`, 20 octets - (optionnel lors de la création d'un nouveau contrat) L'adresse vers laquelle la transaction est orientée. +- `gaz` : `QUANTITY` - (facultatif, par défaut : 90 000) Nombre entier du gaz fourni pour l'exécution de la transaction. Il retournera du gaz inutilisé. +- `gasPrice` : `QUANTITY` - (facultatif, par défaut : To-Be-Determined) Nombre entier du prix du gaz utilisé pour chaque gaz payé. +- `value` : `QUANTITY` - (facultatif) Nombre entier de la valeur envoyée avec cette transaction. +- `data` : `DATA` - Le code compilé d'un contrat OU le hachage de la signature de la méthode invoquée et des paramètres encodés. +- `nonce` : `QUANTITY` - (facultatif) Entier d'un nonce. Cela permet d'écraser vos propres transactions en attente qui utilisent le même nonce. + +```js +params: [ + { + from: "0xb60e8dd61c5d32be8058bb8eb970870f07233155", + to: "0xd46e8dd67c5d32be8058bb8eb970870f07244567", + gas: "0x76c0", // 30400 + gasPrice: "0x9184e72a000", // 10000000000000 + value: "0x9184e72a", // 2441406250 + data: "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675", + }, +] +``` + +**Retours** + +`DATA`, 32 octets - le hachage de la transaction, ou le hachage zéro si la transaction n'est pas encore disponible. + +Utilisez [eth_getTransactionReceipt](#eth_gettransactionreceipt) pour obtenir l'adresse du contrat, après que la transaction ait été minée, lorsque vous avez créé un contrat. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{see above}],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331" +} +``` + +### eth_sendRawTransaction {#eth_sendrawtransaction} + +Crée une nouvelle transaction d'appel de message ou une création de contrat pour les transactions signées. + +**Paramètres** + +1. `DATA`, Les données de transaction signées. + +```js +params: [ + "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675", +] +``` + +**Retours** + +`DATA`, 32 octets - le hachage de la transaction, ou le hachage zéro si la transaction n'est pas encore disponible. + +Utilisez [eth_getTransactionReceipt](#eth_gettransactionreceipt) pour obtenir l'adresse du contrat, après que la transaction a été minée, lorsque vous avez créé un contrat. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[{see above}],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331" +} +``` + +### eth_call {#eth_call} + +Exécute un nouvel appel de message immédiatement sans créer de transaction sur la chaîne de blocs. + +**Paramètres** + +1. `Object` - L'objet d'appel de transaction + +- `from` : `DATA`, 20 octets - (optionnel) - L'adresse à partir de laquelle la transaction est envoyée. +- `to` : `DATA`, 20 octets - L'adresse à laquelle la transaction est orientée. +- `gaz`: `QUANTITY` - (facultatif) Nombre entier du gaz fourni pour l'exécution de la transaction. eth_call consomme zéro gaz, mais ce paramètre peut être nécessaire pour certaines exécutions. +- `gasPrice` : `QUANTITY` - (facultatif) Nombre entier du prix du gaz utilisé pour chaque gaz payé +- `value` : `QUANTITY` - (facultatif) Nombre entier de la valeur envoyée avec cette transaction +- `data` : `DATA` - Hachage (facultatif) de la signature de la méthode et des paramètres encodés. Pour plus de détails, voir [le contrat Ethereum ABI dans la documentation de Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html) + +2. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« latest »`, `« earliest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block) + +**Retours** + +`DATA` - la valeur de retour du contrat exécuté. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x" +} +``` + +### eth_estimateGas {#eth_estimategas} + +Génère et retourne une estimation de la quantité de gaz nécessaire à la réalisation de la transaction. La transaction ne sera pas ajoutée à la blockchain. Notez que l'estimation peut être beaucoup plus grande que la quantité de gaz réellement utilisée par la transaction, pour diverses raisons, y compris la mécanique EVM et la performance des nœuds. + +**Paramètres** + +Voir les paramètres de [eth_call](#eth_call) , hormis le fait que toutes les propriétés sont facultatives. Si aucune limite de gaz n'est spécifiée, geth utilise la limite de gaz du bloc en attente comme une limite supérieure. En conséquence, l'estimation retournée pourrait ne pas suffire à exécuter l'appel/la transaction lorsque la quantité de gaz est supérieure à la limite de gaz bloc en attente. + +**Valeur de retour** + +`QUANTITY` - la quantité de gaz utilisée. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{see above}],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x5208" // 21000 +} +``` + +### eth_getBlockByHash {#eth_getblockbyhash} + +Retourne des informations à propos d'un bloc par hachage. + +**Paramètres** + +1. `DATA`, 32 octets - Hachage d'un bloc. +2. `Boolean` - Si `true` il retourne les objets de transaction complets, si `false` seulement les hachages des transactions. + +```js +params: [ + "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", + false, +] +``` + +**Valeur de retour** + +`Object` - Un objet bloc, ou `null` quand aucun bloc n'a été trouvé : + +- `number` : `QUANTITY` - le numéro du bloc. `null` quand son bloc est en attente. +- `hash` : `DATA`, 32 octets - hachage du bloc. `null` quand son bloc est en attente. +- `parentHash` : `DATA`, 32 octets - hachage du bloc parent. +- `nonce` : `DATA`, 8 octets - hachage de la preuve de travail générée. `null` quand son bloc est en attente. +- `sha3Uncles` : `DATA`, 32 octets - SHA3 des oncles données dans le bloc. +- `logsBloom` : `DATA`, 256 octets - le filtre bloom pour les logs du bloc. `null` quand son bloc est en attente. +- `transactionsRoot` : `DATA`, 32 octets - la racine de la tentative de transaction du bloc. +- `stateRoot` : `DATA`, 32 octets - la racine de l'état final du bloc. +- `receiptsRoot` : `DATA`, 32 octets - la racine de la tentative de réception du bloc. +- `miner` : `DATA`, 20 octets - l'adresse du bénéficiaire auquel les récompenses minières ont été données. +- `difficulty` : `QUANTITY` - entier de la difficulté pour ce bloc. +- `totalDifficulty` : `QUANTITY` - entier de la difficulté globale de la chaîne jusqu'à ce bloc. +- `extraData` : `DATA` - le champ « données supplémentaires » de ce bloc. +- `size` : `QUANTITY` - entier de la taille de ce bloc en octets. +- `gasLimit` : `QUANTITY` - le gaz maximum autorisé dans ce bloc. +- `gasUsed`: `QUANTITY` - le total utilisé par toutes les transactions de ce bloc. +- `timestamp`: `QUANTITY` - l'horodatage unix pour le moment où le bloc a été assemblé. +- `transactions`: `Array` - Tableau d'objets de transaction, ou hachage de transaction 32 octets dépendant du dernier paramètre donné. +- `uncles`: `Array` - Tableau de hachages d'oncle. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", false],"id":1}' +// Result +{ +{ +"jsonrpc": "2.0", +"id": 1, +"result": { + "difficulty": "0x4ea3f27bc", + "extraData": "0x476574682f4c5649562f76312e302e302f6c696e75782f676f312e342e32", + "gasLimit": "0x1388", + "gasUsed": "0x0", + "hash": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "miner": "0xbb7b8287f3f0a933474a79eae42cbca977791171", + "mixHash": "0x4fffe9ae21f1c9e15207b1f472d5bbdd68c9595d461666602f2be20daf5e7843", + "nonce": "0x689056015818adbe", + "number": "0x1b4", + "parentHash": "0xe99e022112df268087ea7eafaf4790497fd21dbeeb6bd7a1721df161a6657a54", + "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", + "size": "0x220", + "stateRoot": "0xddc8b0234c2e0cad087c8b389aa7ef01f7d79b2570bccb77ce48648aa61c904d", + "timestamp": "0x55ba467c", + "totalDifficulty": "0x78ed983323d", + "transactions": [ + ], + "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421", + "uncles": [ + ] +} +} +``` + +### eth_getBlockByNumber {#eth_getblockbynumber} + +Renvoie des informations sur un bloc par numéro de bloc. + +**Paramètres** + +1. `QUANTITY|TAG` - numéro de bloc entier, ou la chaîne `« earliest »`, `« latest »` ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block). +2. `Boolean` - Si `true` il retourne les objets de transaction complètes, si `false` seulement les hachages des transactions. + +```js +params: [ + "0x1b4", // 436 + true, +] +``` + +**Retourne** Voir [eth_getBlockByHash](#eth_getblockbyhash) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x1b4", true],"id":1}' +``` + +Résultat voir [eth_getBlockByHash](#eth_getblockbyhash) + +### eth_getTransactionByHash {#eth_gettransactionbyhash} + +Retourne les informations sur une transaction demandée par le hachage de la transaction. + +**Paramètres** + +1. `DATA`, 32 octets - hachage d'une transaction + +```js +params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"] +``` + +**Valeur de retour** + +`Object` - Un objet de transaction, ou `null` quand aucune transaction n'a été trouvée : + +- `blockHash`: `DATA`, 32 octets - hachage du bloc dans lequel se trouvait cette transaction. `null` lors de son attente. +- `blockNumber`: `QUANTITY` - numéro de bloc où se trouvait cette transaction. `null` lors de son attente. +- `from`: `DATA`, 20 octets - adresse de l'expéditeur. +- `gas`: `QUANTITY` - gaz fourni par l'expéditeur. +- `gasPrice`: `QUANTITY` - prix du gaz fourni par l'expéditeur en Wei. +- `hash`: `DATA`, 32 octets - hachage de la transaction. +- `input`: `DATA` - les données envoyées avec la transaction. +- `nonce`: `QUANTITY` - le nombre de transactions effectuées par l'expéditeur avant celle-ci. +- `to`: `DATA`, 20 octets - adresse du destinataire. `null` lors d'une transaction de création de contrat. +- `transactionIndex`: `QUANTITY` - nombre entier de la position de l'indice des transactions dans le bloc. `null` lors de son attente. +- `valeur`: `QUANTITY` - valeur transférée dans Wei. +- `v`: `QUANTITY` - Identifiant de récupération ECDSA +- `r`: `QUANTITY` - Signature ECDSA r +- `s`: `QUANTITY` - Signature ECDSA s + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"],"id":1}' +// Result +{ + "jsonrpc":"2.0", + "id":1, + "result":{ + "blockHash":"0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2", + "blockNumber":"0x5daf3b", // 6139707 + "from":"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d", + "gas":"0xc350", // 50000 + "gasPrice":"0x4a817c800", // 20000000000 + "hash":"0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b", + "input":"0x68656c6c6f21", + "nonce":"0x15", // 21 + "to":"0xf02c1c8e6114b1dbe8937a39260b5b0a374432bb", + "transactionIndex":"0x41", // 65 + "value":"0xf3dbb76162000", // 4290000000000000 + "v":"0x25", // 37 + "r":"0x1b5e176d927f8e9ab405058b2d2457392da3e20f328b16ddabcebc33eaac5fea", + "s":"0x4ba69724e8f69de52f0125ad8b3c5c2cef33019bac3249e2c0a2192766d1721c" + } +} +``` + +### eth_getTransactionByBlockHashAndIndex {#eth_gettransactionbyblockhashandindex} + +Retourne des informations sur une transaction par hachage de bloc et la position de l'indice de transaction. + +**Paramètres** + +1. `DATA`, 32 octets - hachage d'un bloc. +2. `QUANTITY` - nombre entier de la position de l'indice de transaction. + +```js +params: [ + "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331", + "0x0", // 0 +] +``` + +**Retourne** Voir [eth_getTransactionByHash](#eth_gettransactionbyhash) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockHashAndIndex","params":["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", "0x0"],"id":1}' +``` + +Résultat voir [eth_getTransactionByHash](#eth_gettransactionbyhash) + +### eth_getTransactionByBlockNumberAndIndex {#eth_gettransactionbyblocknumberandindex} + +Retourne des informations sur une transaction par numéro de bloc et la position de l'indice de transaction. + +**Paramètres** + +1. `QUANTITY|TAG` - numéro de bloc, ou la chaîne `« earliest »` ,`« latest »`, ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block). +2. `QUANTITY` - position de l'indice de transaction. + +```js +params: [ + "0x29c", // 668 + "0x0", // 0 +] +``` + +**Retourne** Voir [eth_getTransactionByHash](#eth_gettransactionbyhash) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockNumberAndIndex","params":["0x29c", "0x0"],"id":1}' +``` + +Résultat voir [eth_getTransactionByHash](#eth_gettransactionbyhash) + +### eth_getTransactionReceipt {#eth_gettransactionreceipt} + +Retourne la réception d'une transaction par hachage de la transaction. + +**Remarque** que le reçu n'est pas disponible pour les transactions en attente. + +**Paramètres** + +1. `DATA`, 32 octets - hachage d'une transaction + +```js +params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"] +``` + +**Renvoie** `Object` - Un objet de réception de transaction, ou `null` quand aucun reçu n'a été trouvé : + +- `transactionHash`: `DATA`, 32 octets - hachage de la transaction. +- `transactionIndex`: `QUANTITY` - nombre entier de la position de l'indice des transactions dans le bloc. +- `blockHash`: `DATA`, 32 octets - hachage du bloc dans lequel se trouvait cette transaction. +- `blockNumber`: `QUANTITY` - numéro de bloc où se trouvait cette transaction. +- `from`: `DATA`, 20 octets - adresse de l'expéditeur. +- `to`: `DATA`, 20 octets - adresse du destinataire. null lors d'une transaction de création de contrat. +- `cumulativeGasUsed` : `QUANTITY` - Le montant total de gaz utilisé lorsque cette transaction a été exécutée dans le bloc. +- `effectiveGasPrice` : `QUANTITY` - La somme des frais de base et du pourboire payés par unité de gaz. +- `gasUsed`: `QUANTITY` - La quantité de gaz utilisée par cette transaction spécifique seule. +- `contractAddress`: `DATA`, 20 octets - L'adresse du contrat a été créée, si la transaction était une création de contrat, sinon `null`. +- `logs`: `Tableau` - Tableau d'objets de log, que cette transaction a générés. +- `logsBloom`: `DATA`, 256 octets - Filtre Bloom pour les clients légers pour récupérer rapidement les logs associés. +- `type`: `QUANTITY` - nombre entier du type de transaction, `0x00` pour les transactions héritées, `0x01` pour les types de listes d'accès, `0x02` pour les frais dynamiques. Il renvoie aussi _soit_ : +- `root` : `DATA` 32 octets de stateroot post-transaction (avant Byzantium) +- `status`: `QUANTITY` soit `1` (succès) ou `0` (échec) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"],"id":1}' +// Result +{ + "jsonrpc": "2.0", + "id": 1, + "result": { + "blockHash": + "0xa957d47df264a31badc3ae823e10ac1d444b098d9b73d204c40426e57f47e8c3", + "blockNumber": "0xeff35f", + "contractAddress": null, // string of the address if it was created + "cumulativeGasUsed": "0xa12515", + "effectiveGasPrice": "0x5a9c688d4", + "from": "0x6221a9c005f6e47eb398fd867784cacfdcfff4e7", + "gasUsed": "0xb4c8", + "logs": [{ + // logs as returned by getFilterLogs, etc. + }], + "logsBloom": "0x00...0", // 256 byte bloom filter + "status": "0x1", + "to": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", + "transactionHash": + "0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5", + "transactionIndex": "0x66", + "type": "0x2" + } +} +``` + +### eth_getUncleByBlockHashAndIndex {#eth_getunclebyblockhashandindex} + +Retourne des informations à propos d'un oncle d'un bloc par hachage et position de l'indice. + +**Paramètres** + +1. `DATA`, 32 octets - Le hachage d'un bloc. +2. `QUANTITY` - La position de l'oncle dans l'indice. + +```js +params: [ + "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", + "0x0", // 0 +] +``` + +**Retourne** Voir [eth_getBlockByHash](#eth_getblockbyhash) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex","params":["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", "0x0"],"id":1}' +``` + +Résultat voir [eth_getBlockByHash](#eth_getblockbyhash) + +**Remarque** : Un oncle ne contient pas de transactions individuelles. + +### eth_getUncleByBlockNumberAndIndex {#eth_getunclebyblocknumberandindex} + +Renvoie des informations à propos d'un oncle d'un bloc par nombre et par position de l'indice. + +**Paramètres** + +1. `QUANTITY|TAG` - numéro de bloc, ou la chaîne `« earliest »` ,`« latest »`, ou `« pending »`, voir le [paramètre de bloc par défaut](/developers/docs/apis/json-rpc/#default-block). +2. `QUANTITY` - la position de l'oncle dans l'indice. + +```js +params: [ + "0x29c", // 668 + "0x0", // 0 +] +``` + +**Retourne** Voir [eth_getBlockByHash](#eth_getblockbyhash) + +**Remarque** : Un oncle ne contient pas de transactions individuelles. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockNumberAndIndex","params":["0x29c", "0x0"],"id":1}' +``` + +Résultat voir [eth_getBlockByHash](#eth_getblockbyhash) + +### eth_getCompilers {#eth_getcompilers} + +Retourne une liste des compilateurs disponibles dans le client. + +**Paramètres :** Aucun + +**Retourne** `Tableau` - Tableau de compilateurs disponibles. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCompilers","params":[],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": ["solidity", "lll", "serpent"] +} +``` + +### eth_compileSolidity {#eth_compile_solidity} + +Retourne le code de solidité compilé. + +**Paramètres** + +1. `String` - Le code source. + +```js +params: [ + "contract test { function multiply(uint a) returns(uint d) { return a * 7; } }", +] +``` + +**Retourne** `DATA` - Le code source compilé. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileSolidity","params":["contract test { function multiply(uint a) returns(uint d) { return a * 7; } }"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": { + "code": "0x605880600c6000396000f3006000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa114602e57005b603d6004803590602001506047565b8060005260206000f35b60006007820290506053565b91905056", + "info": { + "source": "contract test {\n function multiply(uint a) constant returns(uint d) {\n return a * 7;\n }\n}\n", + "language": "Solidity", + "languageVersion": "0", + "compilerVersion": "0.9.19", + "abiDefinition": [ + { + "constant": true, + "inputs": [ + { + "name": "a", + "type": "uint256" + } + ], + "name": "multiply", + "outputs": [ + { + "name": "d", + "type": "uint256" + } + ], + "type": "function" + } + ], + "userDoc": { + "methods": {} + }, + "developerDoc": { + "methods": {} + } + } +} +``` + +### eth_compileLLL {#eth_compileLLL} + +Retourne le code LLL compilé. + +**Paramètres** + +1. `String` - Le code source. + +```js +params: ["(returnlll (suicide (caller)))"] +``` + +**Retourne** `DATA` - Le code source compilé. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileLLL","params":["(returnlll (suicide (caller)))"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056" // the compiled source code +} +``` + +### eth_compileSerpent {#eth_compileserpent} + +Retourne le code du serpent compilé. + +**Paramètres** + +1. `String` - Le code source. + +```js +params: ["/* some serpent */"] +``` + +**Retourne** `DATA` - Le code source compilé. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileSerpent","params":["/* some serpent */"],"id":1}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056" // the compiled source code +} +``` + +### eth_newFilter {#eth_newfilter} + +Crée un objet filtre, basé sur les options de filtre, pour avertir lorsque l'état change (logs). Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges). + +**Une note sur la spécification des filtres de sujet :** Les sujets sont dépendants de l'ordre. Une transaction avec un journal avec des sujets [A, B] sera mise en correspondance par les filtres de discussion suivants : + +- `[]` « n'importe quoi » +- `[A]`: « A en première position (et n'importe quoi après) » +- `[null, B]` « tout ce qui est en première position ET B en seconde position (et tout ce qui est après) » +- `[A, B]` « A en première position ET B en deuxième position (et tout ce qui suivra) » +- `[[A, B], [A, B]]` « (A OU B) en première position ET (A OU B) en deuxième position (et n'importe quoi après) » +- **Paramètres** + +1. `Object` - Les options de filtre : + +- `fromBlock`: `QUANTITY|TAG` - (optionnel, par défaut : `« latest »`) nombre de blocs entiers, ou `« latest »` pour le dernier bloc miné ou `« pendant »`, `« earliest »` pour les transactions non encore minées. +- `toBlock`: `QUANTITY|TAG` - (facultatif, par défaut : `« latest »`) Numéro de bloc d'entier ou `« latest »` pour le dernier bloc miné ou `« pending »`, `« earliest »` pour les transactions non encore minées. +- `address`: `DATA|Array`, 20 octets - (facultatif) adresse contractuelle ou une liste d'adresses d'où les logs doivent provenir. +- `topics` : `Array of DATA`, - (facultatif) tableau de sujets `DATA` de 32 bytes. Les sujets dépendent de l'ordre. Chaque sujet peut également être un tableau de DATA avec des options « ou ». + +```js +params: [ + { + fromBlock: "0x1", + toBlock: "0x2", + address: "0x8888f1f195afa192cfee860698584c030f4c9db1", + topics: [ + "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b", + null, + [ + "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b", + "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc", + ], + ], + }, +] +``` + +**Renvoie** `QUANTITY` - Un id de filtre. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topics":["0x12341234"]}],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x1" // 1 +} +``` + +### eth_newBlockFilter {#eth_newblockfilter} + +Crée un filtre dans le nœud, pour avertir lorsqu'un nouveau bloc arrive. Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges). + +**Paramètres :** Aucun + +**Renvoie** `QUANTITY` - Un id de filtre. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x1" // 1 +} +``` + +### eth_newPendingTransactionFilter {#eth_newpendingtransactionfilter} + +Crée un filtre dans le nœud, pour notifier quand de nouvelles transactions en attente arrivent. Pour vérifier si l'état a changé, appelez [eth_getFilterChanges](#eth_getfilterchanges). + +**Paramètres :** Aucun + +**Renvoie** `QUANTITY` - Un id de filtre. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter","params":[],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0x1" // 1 +} +``` + +### eth_uninstallFilter {#eth_uninstallfilter} + +Désinstalle un filtre avec un identifiant donné. Doit toujours être appelé lorsque la montre n'est plus nécessaire. De plus, filtre le délai d'attente quand ils ne sont pas demandés avec [eth_getFilterChanges](#eth_getfilterchanges) pour une période de temps. + +**Paramètres** + +1. `QUANTITY` - Le id du filtre. + +```js +params: [ + "0xb", // 11 +] +``` + +**Retourne** `Boolean` - `true` si le filtre a été désinstallé avec succès, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_uninstallFilter","params":["0xb"],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": true +} +``` + +### eth_getFilterChanges {#eth_getfilterchanges} + +Méthode de vote pour un filtre, qui retourne un tableau de logs qui s'est produit depuis le dernier sondage. + +**Paramètres** + +1. `QUANTITY` - l'id du filtre. + +```js +params: [ + "0x16", // 22 +] +``` + +**Retourne** `Array` - Tableau d'objets de log, ou un tableau vide si rien n'a changé depuis le dernier sondage. + +- Pour les filtres créés avec `eth_newBlockFilter` le retour constitue des hachages de blocs (`DATA`, 32 octets), par exemple `["0x3454645634534..."]`. +- Pour les filtres créés avec `eth_newPendingTransactionFilter` le retour constitue des hachages de transaction (`DATA`, 32 octets), par exemple `["0x6345343454645..."]`. +- Pour les filtres créés avec `eth_newFilter`, les logs sont des objets avec les paramètres suivants : + - `removed` : `TAG` - `true` lorsque le journal a été supprimé, en raison d'une réorganisation de chaîne. `false` si c'est un journal valide. + - `logIndex`: `QUANTITY` - nombre entier de la position de l'indice des logs dans le bloc. `null` lors de son log en attente. + - `transactionIndex` : `QUANTITY` - nombre entier à partir duquel le log de position de l'indice des transactions a été créé. `null` lors de son log en attente. + - `transactionHash` : `DATA`, 32 octets - hachage des transactions à partir desquelles ce log a été créé. `null` lors de son log en attente. + - `blockHash` : `DATA`, 32 octets - hachage du bloc dans lequel se trouvait ce log. `null` lors de son attente. `null` lors de son log en attente. + - `blockNumber` : `QUANTITY` - le numéro de bloc où se trouvait ce log. `null` lors de son attente. `null` lors de son log en attente. + - `address`: `DATA`, 20 octets - adresse à partir de laquelle ce journal est originaire. + - `data`: `DATA` - contient un ou plus de 32 octets d'arguments non indexés du log. + - `topics`: `Array of DATA` - Tableau de 0 à 4 32 octets `DATA` d'arguments de log indexés. (Dans _Solidity_: Le premier sujet est le _hash_ de la signature de l'événement (par ex. `Déposit(adresse,octets32,uint256)`), sauf que vous avez déclaré l'événement avec le `spécificateur anonyme`.) +- **Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":["0x16"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": [{ + "logIndex": "0x1", // 1 + "blockNumber":"0x1b4", // 436 + "blockHash": "0x8216c5785ac562ff41e2dcfdf5785ac562ff41e2dcfdf829c5a142f1fccd7d", + "transactionHash": "0xdf829c5a142f1fccd7d8216c5785ac562ff41e2dcfdf5785ac562ff41e2dcf", + "transactionIndex": "0x0", // 0 + "address": "0x16c5785ac562ff41e2dcfdf829c5a142f1fccd7d", + "data":"0x0000000000000000000000000000000000000000000000000000000000000000", + "topics": ["0x59ebeb90bc63057b6515673c3ecf9438e5058bca0f92585014eced636878c9a5"] + },{ + ... + }] +} +``` + +### eth_getFilterLogs {#eth_getfilterlogs} + +Retourne un tableau de tous les logs correspondant au filtre avec l'id donné. + +**Paramètres** + +1. `QUANTITY` - Le id du filtre. + +```js +params: [ + "0x16", // 22 +] +``` + +**Retourne** Voir [eth_getFilterChanges](#eth_getfilterchanges) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x16"],"id":74}' +``` + +Résultats voir [eth_getFilterChanges](#eth_getfilterchanges) + +### eth_getLogs {#eth_getlogs} + +Retourne un tableau de tous les logs correspondant à un objet filtre donné. + +**Paramètres** + +1. `Object` - Les options de filtre : + +- `fromBlock`: `QUANTITY|TAG` - (optionnel, par défaut : `« latest »`) nombre de blocs entiers, ou `« latest »` pour le dernier bloc miné ou `« pendant »`, `« earliest »` pour les transactions non encore minées. +- `toBlock`: `QUANTITY|TAG` - (facultatif, par défaut : `« latest »`) Numéro de bloc d'entier ou `« latest »` pour le dernier bloc miné ou `« pending »`, `« earliest »` pour les transactions non encore minées. +- `address`: `DATA|Array`, 20 octets - (facultatif) adresse contractuelle ou une liste d'adresses d'où les logs doivent provenir. +- `topics` : `Array of DATA`, - (facultatif) tableau de sujets `DATA` de 32 bytes. Les sujets dépendent de l'ordre. Chaque sujet peut également être un tableau de DATA avec des options « ou ». +- `blockhash`: `DATA`, 32 octets - (facultatif, **futur**) À l'ajout de EIP-234, `blockHash` sera une nouvelle option de filtre qui restreint les logs retournés au bloc unique avec le hachage de 32 octets `blockHash`. Utiliser `blockHash` est équivalent à `fromBlock` = `toBlock` = le numéro de bloc avec le hachage `blockHash`. Si `blockHash` est présent dans les critères de filtre, alors ni `fromBlock` ni `toBlock` ne sont autorisés. + +```js +params: [ + { + topics: [ + "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b", + ], + }, +] +``` + +**Retourne** Voir [eth_getFilterChanges](#eth_getfilterchanges) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}' +``` + +Résultats voir [eth_getFilterChanges](#eth_getfilterchanges) + +### eth_getWork {#eth_getwork} + +Retourne le hachage du bloc courant, le seedHash, et la condition limite à remplir (« cible »). + +**Paramètres :** Aucun + +**Retourne** `Array` - Tableau avec les propriétés suivantes : + +1. `DATA`, 32 octets - entête de bloc en cours en pow-hash +2. `DATA`, 32 octets - le hachage de la graine utilisé pour le DAG. +3. `DATA`, 32 octets - la condition limite (« cible »), 2^256 / difficulté. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getWork","params":[],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": [ + "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", + "0x5EED00000000000000000000000000005EED0000000000000000000000000000", + "0xd1ff1c01710000000000000000000000d1ff1c01710000000000000000000000" + ] +} +``` + +### eth_submitWork {#eth_submitwork} + +Utilisé pour soumettre une solution de preuve de travail. + +**Paramètres** + +1. `DATA`, 8 octets - Le nonce trouvé (64 bits) +2. `DATA`, 32 octets - Le hachage de l'en-tête (256 bits) +3. `DATA`, 32 octets - Le résumé de mix (256 bits) + +```js +params: [ + "0x0000000000000001", + "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", + "0xD1FE5700000000000000000000000000D1FE5700000000000000000000000000", +] +``` + +**Renvoie** `Booléen` - renvoie `true` si la solution fournie est valide, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0", "method":"eth_submitWork", "params":["0x0000000000000001", "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000D1GE5700000000000000000000000000"],"id":73}' +// Result +{ + "id":73, + "jsonrpc":"2.0", + "result": true +} +``` + +### eth_submitHashrate {#eth_submithashrate} + +Utilisé pour soumettre le hashrate de minage. + +**Paramètres** + +1. `Hashrate`, une chaîne de caractères hexadécimale représentant (32 octets) du hashrate +2. `ID`, Chaîne - Un identifiant hexadécimal aléatoire (32 octets) identifiant le client + +```js +params: [ + "0x0000000000000000000000000000000000000000000000000000000000500000", + "0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c", +] +``` + +**Retourne** `Booléen` - renvoie `true` si la soumission a été effectuée avec succès et `false` autrement. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0", "method":"eth_submitHashrate", "params":["0x0000000000000000000000000000000000000000000000000000000000500000", "0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c"],"id":73}' +// Result +{ + "id":73, + "jsonrpc":"2.0", + "result": true +} +``` + +### db_putString (deprecated) {#db_putstring} + +Stocke une chaîne dans la base de données locale. + +**Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `String` - Nom de la base de données. +2. `String` - Nom de la clé. +3. `String` - Chaîne à stocker. + +```js +params: ["testDB", "myKey", "myString"] +``` + +**Retourne** `Booléen` - retourne `true` si la valeur était stockée, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"db_putString","params":["testDB","myKey","myString"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": true +} +``` + +### db_getString (deprecated) {#db_getstring} + +Retourne une chaîne depuis la base de données locale. **Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `String` - Nom de la base de données. +2. `String` - Nom de la clé. + +```js +params: ["testDB", "myKey"] +``` + +**Retourne** `String` - La chaîne de caractères précédemment stockée. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"db_getString","params":["testDB","myKey"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": "myString" +} +``` + +### db_putHex (deprecated) {#db_puthex} + +Stocke les données binaires dans la base de données locale. **Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `String` - Nom de la base de données. +2. `String` - Nom de la clé. +3. `DATA` - Les données à stocker. + +```js +params: ["testDB", "myKey", "0x68656c6c6f20776f726c64"] +``` + +**Retourne** `Booléen` - retourne `true` si la valeur était stockée, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"db_putHex","params":["testDB","myKey","0x68656c6c6f20776f726c64"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": true +} +``` + +### db_getHex (deprecated) {#db_gethex} + +Retourne des données binaires depuis la base de données locale. **Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `String` - Nom de la base de données. +2. `String` - Nom de la clé. + +```js +params: ["testDB", "myKey"] +``` + +**Retourne** `DATA` - Les données précédemment stockées. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"db_getHex","params":["testDB","myKey"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": "0x68656c6c6f20776f726c64" +} +``` + +### shh_version (deprecated) {#shh_post} + +Retourne la version actuelle du protocole de chuchotement. + +**Remarque :** cette fonction est obsolète. + +**Paramètres :** Aucun + +**Retourne** `String` - La version actuelle du protocole de chuchotement + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_version","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "2" +} +``` + +### shh_post (deprecated) {#shh_version} + +Envoie un message chuchoté. + +**Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `Object` - L'objet du message chuchoté : + +- `from`: `DATA`, 60 octets - (facultatif) L'identité de l'expéditeur. +- `to`: `DATA`, 60 octets - (facultatif) L'identité du destinataire. Lorsque le chuchotement présent chiffrera le message de sorte que seul le récepteur peut le déchiffrer. +- `topics`: `Array of DATA` - Tableau de sujets `DATA` pour que le destinataire identifie des messages. +- `payload`: `DATA` - La charge utile du message. +- `priority`: `QUANTITY` - Le nombre entier de la priorité dans un rang de ... (?). +- `ttl`: `QUANTITY` - nombre entier de l'instant à vivre en secondes. + +```js +params: [ + { + from: "0x04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a03e245533f97284d442460f2998cd41858798ddfd4d661997d3940272b717b1", + to: "0x3e245533f97284d442460f2998cd41858798ddf04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a0d4d661997d3940272b717b1", + topics: [ + "0x776869737065722d636861742d636c69656e74", + "0x4d5a695276454c39425154466b61693532", + ], + payload: "0x7b2274797065223a226d6", + priority: "0x64", + ttl: "0x64", + }, +] +``` + +**Retourne** `Booléen` - renvoie `true` si le message a été envoyé, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_post","params":[{"from":"0xc931d93e97ab07fe42d923478ba2465f2..","topics": ["0x68656c6c6f20776f726c64"],"payload":"0x68656c6c6f20776f726c64","ttl":0x64,"priority":0x64}],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": true +} +``` + +### shh_newIdentity (obsolète){#shh_newidentity} + +Crée une nouvelle identité chuchoteuse dans le client. + +**Remarque :** cette fonction est obsolète. + +**Paramètres :** Aucun + +**Retourne** `DATA`, 60 octets - l'adresse de la nouvelle identité. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newIdentity","params":[],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xc931d93e97ab07fe42d923478ba2465f283f440fd6cabea4dd7a2c807108f651b7135d1d6ca9007d5b68aa497e4619ac10aa3b27726e1863c1fd9b570d99bbaf" +} +``` + +### shh_hasIdentity (deprecated){#shh_hasidentity} + +Vérifie si le client détient les clés privées pour une identité donnée. + +**Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `DATA`, 60 octets - L'adresse de l'identité à vérifier. + +```js +params: [ + "0x04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a03e245533f97284d442460f2998cd41858798ddfd4d661997d3940272b717b1", +] +``` + +**Renvoie** `Boolean` - renvoie `true` si le client détient la clé privée pour cette identité, sinon `faux`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_hasIdentity","params":["0x04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a03e245533f97284d442460f2998cd41858798ddfd4d661997d3940272b717b1"],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": true +} +``` + +### shh_newGroup (deprecated){#shh_newgroup} + +**Remarque :** cette fonction est obsolète. + +**Paramètres :** Aucun + +**Renvoie** `DATA`, 60 octets - l'adresse du nouveau groupe. (?) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newGroup","params":[],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": "0xc65f283f440fd6cabea4dd7a2c807108f651b7135d1d6ca90931d93e97ab07fe42d923478ba2407d5b68aa497e4619ac10aa3b27726e1863c1fd9b570d99bbaf" +} +``` + +### shh_addToGroup (deprecated){#shh_addtogroup} + +**Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `DATA`, 60 octets - L'adresse d'identité à ajouter à un groupe (?). + +```js +params: [ + "0x04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a03e245533f97284d442460f2998cd41858798ddfd4d661997d3940272b717b1", +] +``` + +**Retourne** `Boolean` - renvoie `true` si l'identité a été ajoutée avec succès au groupe, sinon `faux`(?). + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_addToGroup","params":["0x04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a03e245533f97284d442460f2998cd41858798ddfd4d661997d3940272b717b1"],"id":73}' +// Result +{ + "id":1, + "jsonrpc": "2.0", + "result": true +} +``` + +### shh_newFilter (deprecated){#shh_newfilter} + +Crée un filtre à notifier, lorsque le client reçoit un message chuchotant correspondant aux options de filtre. **Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `Object` - Les options de filtre : + +- `to` : `DATA`, 60 octets - (facultatif) Identité du destinataire. _Lorsqu'il est présent, il tentera de déchiffrer tout message entrant si le client détient la clé privée de cette identité._ +- `topics` : `Array of DATA` - Tableau de sujets `DATA` auxquels les sujets du message entrant doivent correspondre. Vous pouvez utiliser les combinaisons suivantes : + - `[A, B] = A && B` + - `[A, [B, C]] = A && (B || C)` + - `[null, A, B] = ANYTHING && A && B` `null` fonctionne comme un caractère générique + - + +```js +params: [ + { + topics: ["0x12341234bf4b564f"], + to: "0x04f96a5e25610293e42a73908e93ccc8c4d4dc0edcfa9fa872f50cb214e08ebf61a03e245533f97284d442460f2998cd41858798ddfd4d661997d3940272b717b1", + }, +] +``` + +**Retourne** `QUANTITY` - Le filtre nouvellement créé. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newFilter","params":[{"topics": ['0x12341234bf4b564f'],"to": "0x2341234bf4b2341234bf4b564f..."}],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": "0x7" // 7 +} +``` + +### shh_uninstallFilter (deprecated){#shh_uninstallfilter} + +Désinstalle un filtre avec un identifiant donné. Doit toujours être appelé lorsque la montre n'est plus nécessaire. De plus, filtre le délai d'attente quand ils ne sont pas demandés avec [shh_getFilterChanges](#shh_getfilterchanges) pour une certaine période. **Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `QUANTITY` - Le id du filtre. + +```js +params: [ + "0x7", // 7 +] +``` + +**Retourne** `Boolean` - `true` si le filtre a été désinstallé avec succès, sinon `false`. + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_uninstallFilter","params":["0x7"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": true +} +``` + +### shh_getFilterChanges (deprecated){#shh_getfilterchanges} + +Méthode de vote pour les filtres chuchotants. Retourne les nouveaux messages depuis le dernier appel de cette méthode. **Note** appelant la méthode [shh_getMessages](#shh_getmessages) va réinitialiser le tampon pour cette méthode afin que vous ne receviez pas de messages dupliqués. **Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `QUANTITY` - Le id du filtre. + +```js +params: [ + "0x7", // 7 +] +``` + +**Retourne** `Array` - Tableau de messages reçus depuis le dernier sondage : + +- `hash` : `DATA`, 32 octets (?) - Le hachage du message. +- `from` : `DATA`, 60 octets - L'expéditeur du message, si un expéditeur a été spécifié. +- `to` : `DATA`, 60 octets - Le récepteur du message, si un récepteur a été spécifié. +- `expiry` : `QUANTITY` - Entier du temps en secondes lorsque ce message doit expirer (?). +- `ttl` : `QUANTITY` - Entier de l'instant où le message doit flotter dans le système en secondes (?). +- `sent` : `QUANTITY` - Entier de l'horodatage Unix lors de l'envoi du message. +- `topics` : `Array of DATA` - Tableau de sujets `DATA` que le message a contenu. +- `payload`: `DATA` - La charge utile du message. +- `workProved` : `QUANTITY` - Entier du travail que ce message a nécessité avant son envoi (?). + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_getFilterChanges","params":["0x7"],"id":73}' +// Result +{ + "id":1, + "jsonrpc":"2.0", + "result": [{ + "hash": "0x33eb2da77bf3527e28f8bf493650b1879b08c4f2a362beae4ba2f71bafcd91f9", + "from": "0x3ec052fc33..", + "to": "0x87gdf76g8d7fgdfg...", + "expiry": "0x54caa50a", // 1422566666 + "sent": "0x54ca9ea2", // 1422565026 + "ttl": "0x64", // 100 + "topics": ["0x6578616d"], + "payload": "0x7b2274797065223a226d657373616765222c2263686...", + "workProved": "0x0" + }] +} +``` + +### shh_getMessages (deprecated) {#shh_getmessages} + +Récupère tous les messages correspondant à un filtre. Contrairement à `shh_getFilterChanges` cela retourne tous les messages. + +**Remarque :** cette fonction est obsolète. + +**Paramètres** + +1. `QUANTITY` - Le id du filtre. + +```js +params: [ + "0x7", // 7 +] +``` + +**Retourne** Voir [shh_getFilterChanges](#shh_getfilterchanges) + +**Exemple** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"shh_getMessages","params":["0x7" +],"id":73}' +``` + +Résultats voir [shh_getFilterChanges](#shh_getfilterchanges) + +## Exemple d'utilisation {#usage-example} + +### Déploiement d'un contrat en utilisant JSON_RPC {#deploying-contract} + +Cette section comprend une démonstration de la façon de déployer un contrat en utilisant uniquement l'interface RPC. Il existe des voies alternatives pour le déploiement de contrats où cette complexité est abstraite, par exemple, en utilisant des bibliothèques construites au dessus de l'interface RPC comme [web3.js](https://web3js.readthedocs.io/) et [web3.py](https://github.com/ethereum/web3.py). Ces abstractions sont généralement plus faciles à comprendre et moins sujettes aux erreurs, mais il est toujours utile de comprendre ce qui se passe sous le capot. + +Ce qui suit est un contrat intelligent simple appelé `Multiply7` qui sera déployé à l'aide de l'interface JSON-RPC sur un nœud Ethereum. Ce tutoriel suppose que le lecteur exécute déjà un nœud Geth. Plus d'informations sur les nœuds et les clients sont disponibles [ici](/developers/docs/nodes-and-clients/run-a-node). Veuillez vous référer à la documentation de [client](/developers/docs/nodes-and-clients/) individuelle pour voir comment démarrer le JSON-RPC HTTP pour les clients non-Geth. La plupart des clients servent par défaut sur `localhost:8545`. + +```javascript +contract Multiply7 { + event Print(uint); + function multiply(uint input) returns (uint) { + Print(input * 7); + return input * 7; + } +} +``` + +La première chose à faire est de s'assurer que l'interface HTTP RPC est activée. Cela signifie que nous fournissons à Geth le drapeau `--http` au démarrage. Dans cet exemple, nous utilisons le nœud Geth dans une chaîne de développement privé. En utilisant cette approche, nous n'avons pas besoin d'éther sur le réseau réel. + +```bash +geth --http --dev console 2>>geth.log +``` + +Cela démarrera l'interface HTTP RPC sur `http://localhost:8545`. + +Nous pouvons vérifier que l'interface fonctionne en récupérant l'adresse et le solde de Coinbase en utilisant [curl](https://curl.se). Veuillez noter que les données contenues dans ces exemples seront différentes sur votre noeud local. Si vous voulez essayer ces commandes, remplacez les paramètres de la requête dans la deuxième requête avec le résultat retourné par la première. + +```bash +curl --data '{"jsonrpc":"2.0","method":"eth_coinbase", "id":1}' -H "Content-Type: application/json" localhost:8545 +{"id":1,"jsonrpc":"2.0","result":["0x9b1d35635cc34752ca54713bb99d38614f63c955"]} + +curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635cc34752ca54713bb99d38614f63c955", "latest"], "id":2}' -H "Content-Type: application/json" localhost:8545 +{"id":2,"jsonrpc":"2.0","result":"0x1639e49bba16280000"} +``` + +Comme les nombres sont encodés en hexa, la balance est retournée en wei sous la forme d'une chaîne hexadécimale. Si nous voulons avoir le solde en éther en tant que numéro, nous pouvons utiliser web3 de la console Geth . + +```javascript +web3.fromWei("0x1639e49bba16280000", "ether") +// "410" +``` + +Maintenant que notre chaîne de développement privé a un certain poids, nous pouvons déployer le contrat. La première étape est de compiler le contrat Multiply7 en byte code qui peut être envoyé à l'EVM. Pour installer solc, le compilateur Solidity, suivez la [documentation Solidity](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Vous pouvez utiliser une ancienne version `solc`à des fins de correspondance à [la version du compilateur utilisée pour notre exemple](https://github.com/ethereum/solidity/releases/tag/v0.4.20).) + +L'étape suivante est de compiler le contrat Multiply7 en code d'octets qui peut être envoyé à l'EVM. + +```bash +echo 'pragma solidity ^0.4.16; contract Multiply7 { event Print(uint); function multiply(uint input) public returns (uint) { Print(input * 7); return input * 7; } }' | solc --bin + +======= :Multiply7 ======= +Binary: +6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029 +``` + +Maintenant que nous avons le code compilé, nous devons déterminer combien de gaz il coûte pour le déployer. L'interface RPC a une méthode `eth_estimateGas` qui nous donnera une estimation. + +```bash +curl --data '{"jsonrpc":"2.0","method": "eth_estimateGas", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 5}' -H "Content-Type: application/json" localhost:8545 +{"jsonrpc":"2.0","id":5,"result":"0x1c31e"} +``` + +Et enfin déployez le contrat. + +```bash +curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "gas": "0x1c31e", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 6}' -H "Content-Type: application/json" localhost:8545 +{"id":6,"jsonrpc":"2.0","result":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"} +``` + +La transaction est acceptée par le noeud et un hachage de la transaction est retourné. Ce hachage peut être utilisé pour suivre la transaction. La prochaine étape consiste à déterminer l'adresse où notre contrat est déployé. Chaque transaction exécutée créera un reçu. Ce reçu contient diverses informations sur la transaction telle que le bloc dans lequel la transaction a été incluse et la quantité de gaz utilisée par l'EVM. Si une transaction crée un contrat, elle contiendra également l'adresse du contrat. Nous pouvons récupérer le reçu avec la méthode `eth_getTransactionReceipt` RPC. + +```bash +curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": ["0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"], "id": 7}' -H "Content-Type: application/json" localhost:8545 +{"jsonrpc":"2.0","id":7,"result":{"blockHash":"0x77b1a4f6872b9066312de3744f60020cbd8102af68b1f6512a05b7619d527a4f","blockNumber":"0x1","contractAddress":"0x4d03d617d700cf81935d7f797f4e2ae719648262","cumulativeGasUsed":"0x1c31e","from":"0x9b1d35635cc34752ca54713bb99d38614f63c955","gasUsed":"0x1c31e","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","status":"0x1","to":null,"transactionHash":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf","transactionIndex":"0x0"}} +``` + +Notre contrat a été créé sur `0x4d03d617d700cf81935d7f797f4e2ae719648262`. Un résultat nul au lieu d'un reçu signifie que la transaction n'a pas encore été intégrée dans un bloc. Attendez un instant et vérifiez si votre mineur est en cours d'exécution et réessayez. + +#### Interagir avec les contrats intelligents {#interacting-with-smart-contract} + +Dans cet exemple, nous enverrons une transaction en utilisant `eth_sendTransaction` à la méthode `multiply` du contrat. + +`eth_sendTransaction` nécessite plusieurs arguments, spécifiquement `from`, `to` et `data`. `From` est l'adresse publique de notre compte et `to` est l'adresse du contrat. L'argument `data` contient une charge utile qui définit quelle méthode doit être appelée et avec quels arguments. C'est ici que [l'ABI (interface binaire de l'application)](https://docs.soliditylang.org/en/latest/abi-spec.html) entre en jeu. L'ABI est un fichier JSON qui définit comment définir et encoder les données pour l'EVM. + +Les octets de la charge utile définissent quelle méthode dans le contrat est appelée. Il s'agit des 4 premiers octets du hachage de Keccak sur le nom de la fonction et ses types d'arguments, encodés en hexa. La fonction multiplier accepte un uint qui est un alias pour uint256. Cela nous laisse avec : + +```javascript +web3.sha3("multiply(uint256)").substring(0, 10) +// "0xc6888fa1" +``` + +L'étape suivante est d'encoder les arguments. Il n'y a qu'un seul uint256, par exemple, la valeur 6. L'ABI a une section qui spécifie comment encoder les types uint256. + +`int: enc(X)` est l'encodage gros-boutiste en complément à deux de X, ajouté sur le côté supérieur (gauche) avec 0xff pour X négatif et avec zéro > octets pour X positif de sorte que la longueur est un multiple de 32 octets. + +Ceci encode en `0000000000000000000000000000000000000000000000000000000000000006`. + +La combinaison du sélecteur de fonction et de l'argument encodé sera `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`. + +Cela peut maintenant être envoyé au nœud : + +```bash +curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0xeb85a5557e5bdc18ee1934a89d8bb402398ee26a", "to": "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d", "data": "0xc6888fa10000000000000000000000000000000000000000000000000000000000000006"}], "id": 8}' -H "Content-Type: application/json" localhost:8545 +{"id":8,"jsonrpc":"2.0","result":"0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74"} +``` + +Puisqu'une transaction a été envoyée, un hachage de transaction a été retourné. La récupération du reçu : + +```javascript +{ + blockHash: "0xbf0a347307b8c63dd8c1d3d7cbdc0b463e6e7c9bf0a35be40393588242f01d55", + blockNumber: 268, + contractAddress: null, + cumulativeGasUsed: 22631, + gasUsed: 22631, + logs: [{ + address: "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d", + blockHash: "0xbf0a347307b8c63dd8c1d3d7cbdc0b463e6e7c9bf0a35be40393588242f01d55", + blockNumber: 268, + data: "0x000000000000000000000000000000000000000000000000000000000000002a", + logIndex: 0, + topics: ["0x24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da"], + transactionHash: "0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74", + transactionIndex: 0 + }], + transactionHash: "0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74", + transactionIndex: 0 +} +``` + +Le reçu contient un journal d'activités. Ce journal a été généré par l'EVM lors de l'exécution de la transaction et est inclus dans le reçu. La fonction `multiply` montre que l'événement `Print` a été levé avec le temps d'entrée 7. Puisque l'argument de l'événement `Print` était un uint256, nous pouvons le décoder selon les règles ABI qui nous laisseront avec la décimale prévue 42. Mis à part les données, il est intéressant de noter que les sujets peuvent être utilisés pour déterminer quel événement a créé le journal : + +```javascript +web3.sha3("Print(uint256)") +// "24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da" +``` + +Il ne s'agissait que d'une brève introduction à certaines des tâches les plus courantes, démontrant l'utilisation directe du JSON-RPC. + ## Sujets connexes {#related-topics} -- [Nœuds et clients](/developers/docs/nodes-and-clients/) +- [Spécification JSON-RPC](http://www.jsonrpc.org/specification) +- [ Nœuds et clients](/developers/docs/nodes-and-clients/) - [API JavaScript](/developers/docs/apis/javascript/) -- [API backend](/developers/docs/apis/backend/) +- [API back-end](/developers/docs/apis/backend/) +- [Clients d'exécution](/developers/docs/nodes-and-clients/#execution-clients) diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md index 5b825dbec3d..e4f53f65b7c 100644 --- a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md +++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/index.md @@ -2,12 +2,13 @@ title: Preuve de travail (PoW) description: Explication du protocole de consensus « preuve de travail » et de son rôle dans Ethereum. lang: fr -incomplete: true --- -Ethereum, comme Bitcoin, utilise actuellement un protocole de consensus appelé **[preuve de travail (PoW)](https://wikipedia.org/wiki/Proof_of_work)**. Celui-ci permet à l'ensemble du réseau Ethereum de s'accorder sur l'état de toutes les informations enregistrées sur la blockchain Ethereum, empêchant ainsi certains types d'attaques économiques. +Le réseau Ethereum a commencé par utiliser un mécanisme de consensus basé sur la **[Preuve de travail (PoW)](/developers/docs/consensus-mechanisms/pow)**. Cela permet à l'ensemble des nœuds du réseau Ethereum de s'accorder sur l'état de toutes les informations enregistrées sur la blockchain Ethereum, empêchant ainsi certains types d'attaques économiques. Ethereum a néanmoins abandonné la preuve de travail en 2022 et a commencé à utiliser la [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos). -Au cours de la prochaine année, la preuve de travail sera progressivement abandonnée au profit de la **[preuve d'enjeu (PoS)](/developers/docs/consensus-mechanisms/pos)**. La transition vers la preuve d'enjeu supprimera également progressivement le minage depuis Ethereum. [En savoir plus sur la fusion.](/roadmap/merge/) + + La preuve de travail est maintenant obsolète. Ethereum n'utilise plus la preuve de travail dans le cadre de son mécanisme de consensus. En lieu et place, Ethereum utilise la preuve d'enjeu. En savoir plus sur la preuve d'enjeu et le staking. + ## Prérequis {#prerequisites} @@ -15,63 +16,59 @@ Pour mieux comprendre cette page, nous vous recommandons de commencer par lire c ## Qu'est ce que la preuve de travail (PoW) ? {#what-is-pow} -La preuve de travail est le mécanisme qui permet au réseau décentralisé Ethereum de parvenir à un consensus, ou de s'accorder sur les soldes des comptes ainsi que l'ordre des transactions. Cela empêche les utilisateurs d'effectuer une « double dépense » et garantit qu'il est extrêmement difficile d'attaquer la chaîne Ethereum ou de la manipuler. +Le consensus Nakamoto, qui utilise la preuve de travail, est le mécanisme qui a autrefois permis au réseau Ethereum décentralisé de parvenir à un consensus (c.-à-d. que l'ensemble des nœuds sont d'accord) sur des choses telles que les soldes des comptes et l'ordre des transactions. Cela empêche les utilisateurs d'effectuer une « double dépense » et garantit qu'il est extrêmement difficile d'attaquer la chaîne Ethereum ou de la manipuler. Ces propriétés de sécurité proviennent désormais de la preuve d'enjeu, en utilisant le mécanisme de consensus connu sous le nom de [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/). ## Preuve de travail et minage {#pow-and-mining} -La preuve de travail est l'algorithme sous-jacent qui définit la difficulté et les règles pour le travail des mineurs. Le minage est le « travail » en lui-même. C'est l'acte d'ajouter des blocs valides à la chaîne. C'est important car la longueur de chaîne aide le réseau à repérer la chaîne Ethereum valide et à comprendre l'état actuel d'Ethereum. Plus il y a de « travail » effectué, plus la chaîne est longue, plus le nombre de blocs est élevé, plus le réseau peut être certain de l'état actuel des choses. +La preuve de travail est l'algorithme sous-jacent qui définit la difficulté et les règles pour le travail réalisé par les mineurs sur les blockchains de preuve de travail. Le minage est le « travail » en lui-même. C'est l'acte d'ajouter des blocs valides à la chaîne. Ce point est important, dans la mesure où la longueur de la chaîne aide le réseau à suivre la bonne fourche de la blockchain. Plus il y a de « travail » effectué, plus la chaîne est longue, plus le nombre de blocs est élevé, plus le réseau peut être certain de l'état actuel des choses. [En savoir plus sur le minage](/developers/docs/consensus-mechanisms/pow/mining/) -## Comment fonctionne la preuve de travail Ethereum ? {#how-it-works} +## Comment fonctionne la preuve de travail pour Ethereum ? {#how-it-works} -Les transactions Ethereum sont traitées en blocs. Chaque bloc possède : +Les transactions Ethereum sont traitées en blocs. Avec le processus désormais obsolète de preuve de travail d'Ethereum, chaque bloc contenait : - une difficulté de bloc (par ex. : 3,324,092,183,262,715) ; - un mixHash (par ex. : `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`) ; - un nonce (par ex. : `0xd3ee432b4fb3d26b`). -Ces données de bloc sont directement liées à la preuve de travail. +Ces données de bloc étaient directement liées à la preuve de travail. ### Le travail en preuve de travail {#the-work} Le protocole de preuve de travail, Ethash, exige des mineurs qu'ils se livrent à une intense course d'essais et d'erreurs pour trouver le nonce d'un bloc. Seuls les blocs avec un nonce valide peuvent être ajoutés à la chaîne. -Lors de la course pour créer un bloc, un mineur soumet de façon répétée un ensemble de données (qu'il ne peut obtenir qu'en téléchargeant et en exécutant la chaîne complète) à une fonction mathématique. Le jeu de données est utilisé pour générer un mixHash en dessous d'un nonce cible, dicté par la difficulté du bloc. La meilleure façon d'y arriver est de faire des essais et des erreurs. +Lors de la course visant à créer un bloc, un mineur soumet de façon répétée un ensemble de données (qu'il ne peut obtenir qu'en téléchargeant et en exécutant la chaîne complète, comme le fait un mineur) à une fonction mathématique. Le jeu de données est utilisé pour générer un mixHash en dessous d'une cible dictée par la difficulté du bloc. La meilleure façon d'y arriver est de faire des essais et des erreurs. La difficulté détermine la cible du hachage. Plus la cible est basse, plus l'ensemble de hachages valides est petit. Une fois généré, il est incroyablement facile à vérifier pour les autres mineurs et clients. Même si une transaction devait changer, le hachage serait complètement différent, signalant une fraude. -Le hachage facilite le dépistage de la fraude. Mais la preuve de travail en tant que processus est aussi un excellent moyen de dissuader ceux qui veulent attaquer la chaîne. +Le hachage facilite la détection de la fraude. Mais la preuve de travail en tant que processus était aussi un excellent moyen de dissuasion contre les attaques de la chaîne. ### Preuve de travail et sécurité {#security} -Les mineurs sont encouragés à faire ce travail sur la chaîne principale Ethereum. Il n’y a guère d’intérêt pour un sous-ensemble de mineurs à démarrer leur propre chaîne. Cela sape le système. Les blockchains reposent sur un seul état comme source de vérité. Et les utilisateurs choisiront toujours la chaîne la plus longue ou la plus « lourde ». +Les mineurs étaient encouragés à faire ce travail sur la chaîne principale Ethereum. Il n’y avait guère d’intérêt pour un sous-ensemble de mineurs à démarrer leur propre chaîne. Cela saperait le système. Les blockchains reposent sur un seul état comme source de vérité. -L'objectif de la preuve de travail est d'étendre la chaîne. La chaîne la plus longue est la plus crédible en terme de validité, car c'est elle qui dispose de plus de travail de calcul. Dans le système de preuve de travail Ethereum, il est presque impossible de créer de nouveaux blocs qui effacent les transactions, en créent de fausses, ou de maintenir une seconde chaîne. C'est parce qu'un mineur malveillant devrait toujours résoudre le bloc plus rapidement que tout le monde. +L'objectif de la preuve de travail était d'étendre la chaîne. La chaîne la plus longue était la plus crédible en termes de validité, car elle enregistrait le travail de calcul le plus important pour la générer. Dans le système de preuve de travail Ethereum, il était presque impossible de créer de nouveaux blocs susceptibles d'effacer les transactions, d'en créer de fausses, ou de maintenir une seconde chaîne. C'est parce qu'un mineur malveillant aurait toujours dû résoudre le nonce du bloc plus rapidement que les autres. -Pour créer systématiquement des blocs malveillants mais valides, vous auriez besoin de plus de 51 % de la puissance de minage du réseau pour battre tout le monde. Une énorme puissance de calcul serait nécessaire pour pouvoir effectuer cette quantité de « travail ». Et l'énergie dépensée pourrait même l'emporter sur les gains que vous feriez lors d'une attaque. +Pour créer de manière constante des blocs malveillants mais valides, un mineur malhonnête aurait besoin de plus de 51 % de la puissance de minage du réseau pour battre tout le monde. Cette quantité de « travail » nécessite une énorme et coûteuse puissance informatique et l'énergie dépensée pourrait même dépasser les gains obtenus avec une attaque. ### Économie de la preuve de travail {#economics} -La preuve de travail est également responsable de l'émission de nouvelles devises dans le système et encourage les mineurs à faire le travail. +La preuve de travail était également responsable de l'émission de nouvelles devises dans le système et encourageait les mineurs à y travailler. -Les mineurs qui ont réussi à créer un bloc sont récompensés par deux ETH fraîchement frappés mais ne reçoivent plus tous les frais de transaction puisque les frais de base sont brûlés, tandis que le pourboire et la récompense du bloc vont au mineur. Un mineur peut également obtenir 1,75 ETH pour un bloc « oncle ». Les blocs « oncle » sont des blocs valides créés par un mineur pratiquement en même temps qu'un autre mineur a miné le bloc avec succès. Les blocs « oncle » apparaissent généralement en raison de la latence du réseau. +Depuis [la mise à jour Constantinople](/history/#constantinople), les mineurs ayant réussi à créer un bloc étaient récompensés par deux ETH fraîchement minés et une partie des frais de transaction. Les blocs Ommer étaient également récompensés par 1,75 ETH. Les blocs Ommer étaient des blocs valides créés par un mineur pratiquement en même temps qu'un autre mineur créait le bloc canonique, qui était finalement déterminé par la chaîne construite en premier. Les blocs Ommer apparaissaient généralement en raison de la latence du réseau. ## Finalisation {#finality} -Une transaction est « finalisée » sur Ethereum lorsqu'elle fait partie d'un bloc qui ne peut pas changer. +Une transaction était « finalisée » sur Ethereum lorsqu'elle faisait partie d'un bloc qui ne pouvait pas changer. -Parce que les mineurs travaillent de manière décentralisée, deux blocs valides peuvent être minés en même temps. Cela crée une fourche temporaire. Finalement, l'une de ces chaînes deviendra la chaîne acceptée après qu'un bloc suivant aura été miné et ajouté, ce qui la rendra plus longue. +Dans la mesure où les mineurs travaillaient de manière décentralisée, deux blocs valides pouvaient être minés en même temps. Cela créait une fourche temporaire. Finalement, l'une de ces chaînes devenait la chaîne acceptée après qu'un bloc suivant aura été miné et ajouté, ce qui la rendra plus longue. -Mais pour compliquer davantage les choses, les transactions rejetées sur la fourche temporaire auront peut-être été incluses dans la chaîne acceptée. Cela signifie que cela pourrait être inversé. La finalisation fait dont référence au délai que vous devez attendre avant de considérer une transaction comme irréversible. Pour Ethereum, le délai recommandé est de six blocs ou un peu plus d'une minute. Après six blocs, vous pouvez penser avec une relative confiance que la transaction est réussie. Vous pouvez attendre plus longtemps pour que votre assurance soit encore plus grandes. - -La finalisation est une chose à garder à l'esprit lors de la conception de dApps. Ce serait une mauvaise expérience utilisateur de dénaturer les informations de transaction à vos utilisateurs, surtout si la transaction est de grande valeur. - -N'oubliez pas que ce délai n'inclut pas les temps d'attente pour qu'une transaction soit prise en charge par un mineur. +Mais pour compliquer davantage les choses, les transactions rejetées sur la fourche temporaire pouvaient ne pas avoir été incluses dans la chaîne acceptée. Cela signifie qu'elle pourrait être inversée. La finalisation fait dont référence au temps que vous devez attendre avant de considérer une transaction comme irréversible. Dans le cadre de la précédente preuve de travail d'Ethereum, plus le nombre de blocs minés au-dessus d'un bloc spécifique `N` était élevé, plus la confiance dans les transactions de `N` était élevée et n'était pas inversée. Désormais, avec la preuve d'enjeu, la finalisation d'un bloc est une propriété explicite, plutôt que probabiliste. ## Consommation d'énergie et preuve de travail {#energy} -Une critique majeure de la preuve de travail est la quantité d'énergie nécessaire pour assurer la sécurité du réseau. Pour maintenir la sécurité et la décentralisation, Ethereum en preuve de travail consomme chaque année 73,2 TWh, l'équivalent énergétique d'un pays de taille moyenne comme l'Autriche. +Une critique majeure de la preuve de travail est la quantité d'énergie nécessaire pour assurer la sécurité du réseau. Pour maintenir la sécurité et la décentralisation, Ethereum consommait de grandes quantités d'énergie avec la preuve de travail. Peu avant de passer à la preuve d'enjeu, les mineurs d'Ethereum consommaient collectivement environ 70 TWh/an (à peu près autant que la République tchèque - selon le [digiconomist](digiconomist.net) le 18 juillet-2022). ## Avantages et inconvénients {#pros-and-cons} @@ -99,7 +96,7 @@ Une critique majeure de la preuve de travail est la quantité d'énergie nécess ## Complément d'information {#further-reading} - [Attaque de la majorité](https://en.bitcoin.it/wiki/Majority_attack) -- [Finalisation du règlement](https://blog.ethereum.org/2016/05/09/on-settlement-finality/) +- [A propos de l'accord de finalisation](https://blog.ethereum.org/2016/05/09/on-settlement-finality/) ### Vidéos {#videos} diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md index 1316a3cdcef..832c5f41e31 100644 --- a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md +++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/index.md @@ -1,44 +1,47 @@ --- title: Minage -description: Une explication du fonctionnement du minage sur Ethereum et de la façon dont il aide à garder Ethereum sécurisé et décentralisé. +description: Une explication de la façon dont le minage fonctionnait sur Ethereum. lang: fr -incomplete: true --- + +La preuve de travail n'est plus le mécanisme de consensus d'Ethereum, ce qui implique que le minage a été désactivé. À la place, Ethereum est sécurisé par les validateurs qui misent de l'ETH. Vous pouvez commencer à miser votre ETH aujourd'hui. En savoir plus sur La Fusion, la preuve d'enjeu et la mise en jeu. Cette page n'a qu'un intérêt historique. + + ## Prérequis {#prerequisites} Pour mieux comprendre cette page, nous vous recommandons de commencer par lire celles concernant [les transactions](/developers/docs/transactions/), [les blocs](/developers/docs/blocks/) et [la preuve de travail](/developers/docs/consensus-mechanisms/pow/). ## Qu'est-ce que le minage Ethereum ? {#what-is-ethereum-mining} -Le minage est le processus de création d'un bloc de transactions à ajouter à la blockchain Ethereum. +Le minage est le processus de création d'un bloc de transactions à ajouter à la blockchain Ethereum dans l'architecture de preuve de travail, désormais obsolète, pour Ethereum. -Ethereum, comme Bitcoin, utilise actuellement un mécanisme de consensus appelé [preuve de travail (PoW)](/developers/docs/consensus-mechanisms/pow/). Le minage est l’essence même de la preuve de travail. Les mineurs d'Ethereum (les ordinateurs qui exécutent des logiciels) utilisent leur temps et leur puissance de calcul pour traiter les transactions et produire des blocs. +Le terme « minage » trouve son origine dans la comparaison avec l'or des crypto-monnaies. L'or et les métaux précieux sont rares, tout comme les jetons numériques, et le seul moyen d'en augmenter le volume dans le cadre du système de preuve de travail est le minage. Dans le cadre de la preuve de travail Ethereum, le seul mode d’émission était le minage. À la différence du minage historique de l'or ou des métaux précieux, le minage avec Ethereum permet également de sécuriser le réseau en créant, vérifiant, publiant et propageant de nouveaux blocs dans la blockchain. - - La Preuve d'enjeu remplacera le minage et la Preuve de travail au cours de l'année prochaine. Vous pouvez commencer à miser votre ETH aujourd'hui. En savoir plus sur les mises - +Miner de l'ether = Sécuriser le réseau + +Le minage est la colonne vertébrale de toute blockchain utilisant la preuve de travail. Les mineurs d'Ethereum - les ordinateurs qui exécutent des logiciels - utilisaient leur puissance de temps et de calcul pour traiter les transactions et produire des blocs avant la transition vers la preuve d'enjeu. ## Pourquoi existe-t-il des mineurs ? {#why-do-miners-exist} -Dans les systèmes décentralisés comme Ethereum, nous devons nous assurer que tout le monde s'accorde sur l'ordre des transactions. Les mineurs aident à cela en résolvant des casse-têtes complexes sur le plan informatique afin de produire des blocs, qui constituent un moyen de sécuriser le réseau des attaques. +Dans les systèmes décentralisés comme Ethereum, nous devons nous assurer que tout le monde s'accorde sur l'ordre des transactions. Les mineurs y contribuent en résolvant des casse-têtes informatiques complexes pour produire des blocs, sécurisant également ainsi le réseau contre les attaques. [En savoir plus sur la preuve de travail](/developers/docs/consensus-mechanisms/pow/) -## Qui peut devenir mineur sur Ethereum ? {#who-can-become-a-miner} - -Techniquement, n'importe qui peut exploiter le réseau Ethereum à l'aide de son ordinateur. Cependant, tout le monde ne peut pas exploiter l'éther (ETH) de manière rentable. Dans la plupart des cas, les mineurs doivent acheter du matériel informatique dédié pour exploiter de manière rentable. S'il est vrai que n'importe qui peut exécuter le logiciel de minage sur son ordinateur, il est peu probable que l'ordinateur moyen gagne suffisamment de récompenses globales pour couvrir les coûts associés au minage. +Auparavant, n'importe qui pouvait miner sur le réseau Ethereum à l'aide de son ordinateur. Cependant, tout le monde ne pouvait pas miner de l'éther (ETH) de manière rentable. Dans la plupart des cas, les mineurs devaient acheter du matériel informatique et des logiciels dédiés et avoir accès à des sources d'énergie peu coûteuses. Il était peu probable que l'ordinateur moyen gagne suffisamment de récompenses de blocs pour couvrir les coûts associés au minage. ### Coût du minage {#cost-of-mining} - Coûts potentiels du matériel nécessaire pour construire et entretenir une plate-forme minière - Coût électrique de l'alimentation de la plate-forme minière -- Si vous minez dans un pool, les pools de minage facturent généralement des frais fixes en % de chaque bloc généré par le pool +- Si vous miniez au sein d'un pool, ces derniers facturaient généralement des frais fixes en % de chaque bloc généré par le pool - Coût potentiel de l'équipement pour soutenir la plate-forme minière (ventilation, surveillance de l'énergie, câblage électrique, etc.) Pour explorer davantage la rentabilité du minage, utilisez un calculateur de minage, tel que celui fourni par [Etherscan](https://etherscan.io/ether-mining-calculator). -## Comment les transactions Ethereum sont-elles minées ? {#how-ethereum-transactions-are-mined} +## Comment les transactions Ethereum étaient-elles minées ? {#how-ethereum-transactions-were-mined} + +Ce qui suit donne un aperçu de la façon dont les transactions ont été exécutés dans la preuve de travail Ethereum. Une description analogue de ce processus pour la preuve d'enjeu Ethereum peut être trouvée [ici](/developers/docs/consensus-mechanisms/pos/#transaction-execution-ethereum-pos). 1. Un utilisateur rédige et signe une demande de [transaction](/developers/docs/transactions/) avec la clé privée d'un [compte](/developers/docs/accounts/). 2. L'utilisateur diffuse la demande de transaction sur l'ensemble du réseau Ethereum à partir de certains [nœuds](/developers/docs/nodes-and-clients/). @@ -51,21 +54,25 @@ Pour explorer davantage la rentabilité du minage, utilisez un calculateur de mi 7. Chaque nœud supprime toutes les transactions du nouveau bloc de son mempool local de demandes de transaction non satisfaites. 8. Les nouveaux nœuds qui rejoignent le réseau téléchargent tous les blocs en séquence, y compris le bloc contenant la transaction qui nous intéresse. Ils initialisent une copie locale de l'EVM (qui débute en tant qu'EVM vide), puis commencent l'exécution de chaque transaction dans chaque bloc en plus de leur copie locale de l'EVM, en vérifiant la somme de contrôle de l'état de chaque bloc dans le processus. -Chaque transaction est minée (incluse dans un nouveau bloc et propagée pour la première fois) une fois, mais exécutée et vérifiée par chaque participant du processus d'avancement vers l'état conforme de l'EVM. Ceci met en avant l'une des devises de la blockchain : **Ne faites pas confiance, vérifiez**. +Chaque transaction est minée (incluse dans un nouveau bloc et propagée pour la première fois) une fois, mais exécutée et vérifiée par chaque participant au processus d'avancement vers l'état conforme de l'EVM. Cette approche met en avant l'une des principales devises de la blockchain : **Ne faites pas confiance, vérifiez**. + +## Blocs ommer (oncle) {#ommer-blocks} + +Le minage du bloc reposant sur la preuve de travail (PoW) n'était alors que probabiliste, ce qui signifie que, parfois, il arrivait que deux blocs, ayant déjà été validés, soient en même temps exposés au public, notamment en raison de la latence du réseau. Dans ce cas, le protocole devait déterminer la chaîne la plus longue (et donc la plus « valide ») tout en assurant l'équité envers les mineurs en récompensant partiellement le bloc valide non inclus proposé. Cela a encouragé une plus grande décentralisation du réseau pour les mineurs plus petits, qui pourraient être confrontés à une plus grande latence, leur permettant de générer des rendements par le biais d'un bloc de récompenses [ommer](/glossary/#ommer) . + +On utilise de préférence le terme « ommer », plus neutre, pour désigner le frère ou la sœur d'un bloc parent, mais on parle aussi parfois d'« oncle ». **Depuis le passage d'Ethereum à la preuve d'enjeu, les blocs Ommer ne sont plus minés** puisque seulement un acteur de l'écosystème peut être élu dans chaque slot. Vous pouvez voir ce changement en visualisant le [graphique historique](https://ycharts.com/indicators/ethereum_uncle_rate) des blocs Ommer minés. ## Démonstration visuelle {#a-visual-demo} -Regardez Austin vous guider à travers le minage et la blockchain. +Regardez Austin vous guider à travers le minage et la blockchain de la preuve de travail. -## Complément d'information {#further-reading} +## L'algorithme de minage {#mining-algorithm} -## Outils connexes {#related-tools} +Le réseau principal Ethereum n'a jamais utilisé qu'un seul algorithme de minage - ['Ethash'](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash). Ethhash était le successeur d'un algorithme R&D original connu sous le nom de ["Dagger-Hashimoto"](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto). -- [Meilleurs mineurs d'Ethereum](https://etherscan.io/stat/miner?range=7&blocktype=blocks) -- [Calculateur de minage Etherscan](https://etherscan.io/ether-mining-calculator) -- [Calculateur de minage Minerstat](https://minerstat.com/coin/ETH) +[Plus de détails sur les algorithmes de minage](/developers/docs/consensus-mechanisms/pow/mining-algorithms/). ## Sujets connexes {#related-topics} diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md new file mode 100644 index 00000000000..73b6e39b976 --- /dev/null +++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md @@ -0,0 +1,334 @@ +--- +title: Dagger-Hashimoto +description: Un regard détaillé sur l'algorithme Dagger-Hashimoto. +lang: fr +--- + +Dagger-Hashimoto représentait l'implémentation et la spécification originales de recherche pour l'algorithme de minage d'Ethereum. Dagger-Hashimoto a été remplacé par [Ethash](#ethash). Le minage a été complètement arrêté avec [La Fusion](/updates/merge) du 15 septembre 2022. Depuis lors, Ethereum a été sécurisé en utilisant à la place un mécanisme de [preuve d'enjeu](/developers/docs/consensus-mechanisms/pos). Cette page a un intérêt historique - l'information fournie n'est plus pertinente depuis La Fusion Ethereum. + +## Prérequis {#prerequisites} + +Pour mieux comprendre cette page, nous vous recommandons de lire d'abord le [consensus de preuve de travail](/developers/docs/consensus-mechanisms/pow), [le minage](/developers/docs/consensus-mechanisms/pow/mining), et [les algorithmes de minage](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms). + +## Dagger-Hashimoto {#dagger-hashimoto} + +Dagger-Hashimoto vise à satisfaire deux objectifs : + +1. **Résistance aux ASIC** : l'avantage de créer du matériel spécialisé pour l'algorithme devrait être aussi faible que possible +2. **Vérification possible par les clients allégés** : un bloc doit être vérifié efficacement par un client allégé. + +Avec une modification supplémentaire, et si cela vous intéresse, nous vous spécifierons également comment réaliser un troisième objectif mais au prix d'une complexité supplémentaire : + +**Le stockage de chaîne complète** : le minage doit nécessiter un stockage de l'état de la blockchain complète (en raison de la structure irrégulière de la tentative d'état d'Ethereum, nous nous attendons à ce qu'un certain raccourcissement soit possible, en particulier pour certains contrats souvent utilisés tout en minimisant ceci). + +## Génération DAG {#dag-generation} + +Le code de l'algorithme sera défini ci-dessous en Python. Premièrement, nous donnons un `encode_int` pour le marquage des entiers non signés de précision spécifiés aux chaînes de caractères. L'inverse est également donné : + +```python +NUM_BITS = 512 + +def encode_int(x): + "Encode an integer x as a string of 64 characters using a big-endian scheme" + o = '' + for _ in range(NUM_BITS / 8): + o = chr(x % 256) + o + x //= 256 + return o + +def decode_int(s): + "Unencode an integer x from a string using a big-endian scheme" + x = 0 + for c in s: + x *= 256 + x += ord(c) + return x +``` + +Nous supposons maintenant que `sha3` est une fonction qui prend un entier et donne un entier, et `dbl_sha3` est une fonction double-sha3 ; si vous convertissez ce code de référence dans une utilisation d'implémentation : + +```python +from pyethereum import utils +def sha3(x): + if isinstance(x, (int, long)): + x = encode_int(x) + return decode_int(utils.sha3(x)) + +def dbl_sha3(x): + if isinstance(x, (int, long)): + x = encode_int(x) + return decode_int(utils.sha3(utils.sha3(x))) +``` + +### Paramètres {#parameters} + +Les paramètres utilisés pour l'algorithme sont : + +```python +SAFE_PRIME_512 = 2**512 - 38117 # Largest Safe Prime less than 2**512 + +params = { + "n": 4000055296 * 8 // NUM_BITS, # Size of the dataset (4 Gigabytes); MUST BE MULTIPLE OF 65536 + "n_inc": 65536, # Increment in value of n per period; MUST BE MULTIPLE OF 65536 + # with epochtime=20000 gives 882 MB growth per year + "cache_size": 2500, # Size of the light client's cache (can be chosen by light + # client; not part of the algo spec) + "diff": 2**14, # Difficulty (adjusted during block evaluation) + "epochtime": 100000, # Length of an epoch in blocks (how often the dataset is updated) + "k": 1, # Number of parents of a node + "w": w, # Used for modular exponentiation hashing + "accesses": 200, # Number of dataset accesses during hashimoto + "P": SAFE_PRIME_512 # Safe Prime for hashing and random number generation +} +``` + +Dans ce cas `P` est une prime choisie telle que `log₂(P)` soit juste un peu en deçà de 512, qui correspond aux 512 bits que nous utilisons pour représenter nos nombres. Notez que seule la dernière moitié du DAG doit être stockée, ainsi le besoin de mémoire commence de fait à 1 Go et augmente de 441 Mo par an. + +### Construction graphique Dagger {#dagger-graph-building} + +La construction graphique Dagger primitive est définie comme suit : + +```python +def produce_dag(params, seed, length): + P = params["P"] + picker = init = pow(sha3(seed), params["w"], P) + o = [init] + for i in range(1, length): + x = picker = (picker * init) % P + for _ in range(params["k"]): + x ^= o[x % i] + o.append(pow(x, params["w"], P)) + return o +``` + +Essentiellement, cela commence par un graphique en tant que nœud unique, `sha3(seed)`, puis, à partir de ce stade, comment l'ajout séquentiel sur d'autres nœuds basés sur des nœuds précédents aléatoires. Lorsqu'un nouveau nœud est créé, la puissance modulaire de la graine est calculée pour sélectionner aléatoirement des indices inférieurs à `i` (en utilisant `x % i` ci-dessus), et les valeurs des noeuds au regard de ces indices sont utilisées dans un calcul pour générer une nouvelle valeur pour `x`, qui est ensuite alimentée par une fonction de preuve de travail sommaire (basée sur XOR) pour finalement générer la valeur du graphique à l'indice `i`. La raison d'être de cette conception particulière est de forcer l'accès séquentiel du DAG ; la valeur suivante du DAG qui sera accessible ne peut pas être déterminée tant que la valeur courante n'est pas connue. Enfin, l’exponentiation modulaire permet de hacher le résultat. + +Cet algorithme repose sur plusieurs résultats de la théorie des nombres. Consultez l'annexe ci-dessous à des fins de discussion. + +## Évaluation du client allégé {#light-client-evaluation} + +La construction du graphique ci-dessus vise à permettre à chaque nœud du graphique d'être reconstruit en calculant une sous-arborescence d'un petit nombre de nœuds et en ne nécessitant qu'une petite quantité de mémoire auxiliaire. Notez qu'avec k=1, la sous-arborescence n'est qu'une chaîne de valeurs allant jusqu'au premier élément du DAG. + +Pour que le DAG fonctionne, la fonction de calcul du client allégé est la suivante : + +```python +def quick_calc(params, seed, p): + w, P = params["w"], params["P"] + cache = {} + + def quick_calc_cached(p): + if p in cache: + pass + elif p == 0: + cache[p] = pow(sha3(seed), w, P) + else: + x = pow(sha3(seed), (p + 1) * w, P) + for _ in range(params["k"]): + x ^= quick_calc_cached(x % p) + cache[p] = pow(x, w, P) + return cache[p] + + return quick_calc_cached(p) +``` + +Il s'agit essentiellement d'une réécriture de l'algorithme ci-dessus qui supprime la boucle de calcul des valeurs pour l'ensemble du DAG et remplace la précédente recherche du nœud par un appel récursif ou une recherche de cache. Notez que pour `k=1` le cache n'est pas nécessaire, bien qu'une optimisation supplémentaire calcule au préalable en fait les premiers milliers de valeurs du DAG et conserve cela en tant que cache statique pour les calculs ; voir l'annexe pour une implémentation de code de cette fonction. + +## Double tampon de DAG {#double-buffer} + +Dans un client complet, un [_double tampon_](https://wikipedia.org/wiki/Multiple_buffering) de 2 DAG produit par la formule ci-dessus est utilisé. L'idée est que les DAG produisent tous les nombres de blocs `epochtime` selon les paramètres ci-dessus. Au lieu d'utiliser le dernier DAG produit, le client utilise le précédent. L'avantage est qu'il permet aux DAG d'être remplacés au fil du temps sans avoir besoin d'incorporer une étape où les mineurs devraient soudainement recalculer toutes les données. Sinon, il existe un risque de ralentissement brutal et temporaire du traitement en chaîne à intervalles réguliers et d'augmentation spectaculaire de la centralisation. Ainsi, il existe un risque d'attaques de 51% au cours de ces quelques minutes avant que toutes les données ne soient recalculées. + +L'algorithme utilisé pour générer l'ensemble des DAG utilisés pour calculer le travail d'un bloc est le suivant : + +```python +def get_prevhash(n): + from pyethereum.blocks import GENESIS_PREVHASH + from pyethereum import chain_manager + if num <= 0: + return hash_to_int(GENESIS_PREVHASH) + else: + prevhash = chain_manager.index.get_block_by_number(n - 1) + return decode_int(prevhash) + +def get_seedset(params, block): + seedset = {} + seedset["back_number"] = block.number - (block.number % params["epochtime"]) + seedset["back_hash"] = get_prevhash(seedset["back_number"]) + seedset["front_number"] = max(seedset["back_number"] - params["epochtime"], 0) + seedset["front_hash"] = get_prevhash(seedset["front_number"]) + return seedset + +def get_dagsize(params, block): + return params["n"] + (block.number // params["epochtime"]) * params["n_inc"] + +def get_daggerset(params, block): + dagsz = get_dagsize(params, block) + seedset = get_seedset(params, block) + if seedset["front_hash"] <= 0: + # No back buffer is possible, just make front buffer + return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz), + "block_number": 0}} + else: + return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz), + "block_number": seedset["front_number"]}, + "back": {"dag": produce_dag(params, seedset["back_hash"], dagsz), + "block_number": seedset["back_number"]}} +``` + +## Hashimoto {#hashimoto} + +L'idée derrière le Hashimoto original est d'utiliser la blockchain comme jeu de données, effectuant un calcul qui sélectionne N indices de la blockchain, rassemble les transactions sur ces indices, exécute un XOR de ces données, et retourne le hachage du résultat. L'algorithme original de Thaddeus Dryja, traduit en Python pour la cohérence, est le suivant : + +```python +def orig_hashimoto(prev_hash, merkle_root, list_of_transactions, nonce): + hash_output_A = sha256(prev_hash + merkle_root + nonce) + txid_mix = 0 + for i in range(64): + shifted_A = hash_output_A >> i + transaction = shifted_A % len(list_of_transactions) + txid_mix ^= list_of_transactions[transaction] << i + return txid_max ^ (nonce << 192) +``` + +Malheureusement, bien que Hashimoto soit considéré comme de la RAM en dur, il repose sur l'arithmétique 256-bit, qui présente des frais supplémentaires de calcul considérables. Cependant, Dagger-Hashimoto n'utilise que les 64 bits les moins significatifs lors de l'indexation de son jeu de données pour résoudre ce problème. + +```python +def hashimoto(dag, dagsize, params, header, nonce): + m = dagsize / 2 + mix = sha3(encode_int(nonce) + header) + for _ in range(params["accesses"]): + mix ^= dag[m + (mix % 2**64) % m] + return dbl_sha3(mix) +``` + +L'utilisation du double SHA3 permet à un formulaire de zéro donnée, une pré-vérification quasi instantanée, vérifiant uniquement qu'une valeur intermédiaire correcte a été fournie. Cette couche extérieure de preuve de travail est très favorable aux ASIC et assez faible, mais existe pour rendre les attaques DDoS encore plus difficiles puisque cette petite quantité de travail doit être réalisée pour produire un bloc qui ne sera pas immédiatement rejeté. Voici la version client allégé : + +```python +def quick_hashimoto(seed, dagsize, params, header, nonce): + m = dagsize // 2 + mix = sha3(nonce + header) + for _ in range(params["accesses"]): + mix ^= quick_calc(params, seed, m + (mix % 2**64) % m) + return dbl_sha3(mix) +``` + +## Minage et vérification {#mining-and-verifying} + +Maintenant, mettons tout cela ensemble dans l'algorithme de minage : + +```python +def mine(daggerset, params, block): + from random import randint + nonce = randint(0, 2**64) + while 1: + result = hashimoto(daggerset, get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + if result * params["diff"] < 2**256: + break + nonce += 1 + if nonce >= 2**64: + nonce = 0 + return nonce +``` + +Voici l'algorithme de vérification : + +```python +def verify(daggerset, params, block, nonce): + result = hashimoto(daggerset, get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + return result * params["diff"] < 2**256 +``` + +Vérification conviviale du client allégé : + +```python +def light_verify(params, header, nonce): + seedset = get_seedset(params, block) + result = quick_hashimoto(seedset["front_hash"], get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + return result * params["diff"] < 2**256 +``` + +Notez également que Dagger-Hashimoto impose des exigences supplémentaires à l'en-tête du bloc: + +- Pour que la vérification de deux couches fonctionne, un en-tête de bloc doit avoir à la fois la valeur nonce et la valeur moyenne pré-sha3 +- Quelque part, un en-tête de bloc doit stocker la sha3 de l'actuel ensemble de données + +## Complément d'information {#further-reading} + +_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ + +## Annexe {#appendix} + +Comme mentionné ci-dessus, le RNG utilisé pour la génération de DAG repose sur des résultats tirés de la théorie des nombres. Premièrement, nous fournissons l'assurance que le RNG Lehmer qui est la base de la variable `picker` dispose d'une période longue. Deuxièmement, nous montrons que `pow(x,3,P)` ne fera pas correspondre `x` à `1` ou `P-1` fourni `x ∈ [2,P-2]` pour commencer. Enfin, nous montrons que `pow(x,3,P)` a un faible taux de collision lorsqu'il est traité comme une fonction de hachage. + +### Générateur de nombre aléatoire Lehmer {#lehmer-random-number} + +Alors que la fonction `produce_dag` n'a pas besoin de produire des nombres aléatoires impartiaux, une menace potentielle est que `seed**i % P` prenne uniquement une poignée de valeurs. Cela pourrait être un avantage pour les mineurs qui reconnaissent le modèle par rapport à ceux qui ne le font pas. + +Pour éviter cela, un résultat de la théorie du nombre est exercé. Un [_Safe Prime_](https://en.wikipedia.org/wiki/Safe_prime) est défini comme un premier `P` tel que `(P-1)/2` est également un nombre premier. L'_ordre_ d'un membre `x` du [groupe multiplicateur](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` est défini pour être le minimum `m` tel que 
xᵐ mod P ≡ 1
+Compte tenu de ces définitions, nous avons : + +> Observation 1. Laisser `x` être un membre du groupe multiplicateur `ℤ/Pℤ` pour un nombre premier sûr `P`. Si `x mod P ≠ 1 mod P` et `x mod P ≠ P-1 mod P`, alors l'ordre de `x` est soit `P-1` soit `(P-1)/2`. + +_Preuve_. Puisque `P` est un nombre premier sécurisé, puis par \[Lagrange's Theorem\]\[lagrange\] nous trouvons que l'ordre de `x` est soit `1`, `2`, `(P-1)/2`, soit `P-1`. + +L'ordre de `x` ne peut pas être `1`, puisque suivant le petit théorème de Fermat, nous avons : + +
xP-1 mod P ≡ 1
+ +C'est pourquoi `x` doit être une identité multiplicative de `ℤ/nℤ`, ce qui est unique. Puisque nous supposons que `x ≠ 1` par hypothèse, ce n'est pas possible. + +L'ordre de `x` ne peut pas être `2` sauf si `x = P-1`, car cela violerait le principe que `P` soit un nombre premier. + +À partir de la proposition ci-dessus, nous pouvons reconnaître que l'itération `(picker * init) % P` aura une longueur de cycle d'au moins `(P-1)/2`. Ceci est dû au fait que nous avons sélectionné `P` pour être un nombre premier sûr approximativement égal à une puissance supérieure de deux, et `init` est dans l'intervalle `[2,2**256+1]`. Étant donné la magnitude de `P`, nous ne devrions jamais nous attendre à un cycle d'exponentiation modulaire. + +Lorsque nous assignons la première cellule dans le DAG (la variable étiquetée `init`), nous calculons `pow(sha3(seed) + 2, 3, P)`. À première vue, cela ne garantit pas que le résultat n'est ni `1` ni `P-1`. Cependant, puisque `P-1` est un nombre premier sûr, nous émettons l'hypothèse supplémentaire suivante, qui est un corollaire de l'observation 1 : + +> Observation 2. Laissons `x` être membre du groupe multiplicateur `ℤ/Pℤ` pour un nombre premier sûr `P`, et laissons `w` être un nombre naturel. Si `x mod P ≠ 1 mod P` et `x mod P ≠ P-1 mod P`, tout comme `w mod P ≠ P-1 mod P` et `w mod P ≠ 0 mod P`, alors `xʷ mod P ≠ 1 mod P` et `xʷ mod P ≠ P-1 mod P` + +### Exponentiation modulaire comme fonction de hachage {#modular-exponentiation} + +Pour certaines valeurs de `P` et `w`, la fonction `pow(x, w, P)` peut présenter de nombreuses collisions. Par exemple, `pow(x,9,19)` ne prend que les valeurs `{1,18}`. + +Étant donné que `P` est un nombre premier, alors un `w` approprié pour une fonction de hachage d'exponentiation modulaire peut être choisi en utilisant le résultat suivant : + +> Observation 3. Laissez `P` être un nombre premier ; `w` et `P-1` sont relativement premiers si et seulement si pour tous les `a` et `b` en `ℤ/Pℤ` : +> +>
+> `aʷ mod P ≡ bʷ mod P` si et seulement si `a mod P ≡ b mod P` +>
+ +Ainsi, étant donné que `P` est un nombre premier et que `w` est relativement premier à `P-1`, nous avons `|{pow(x, w, P) : x ∈ ℤ}| = P`, ce qui implique que la fonction de hachage a le taux de collision minimal possible. + +Dans le cas spécial ou `P` est un nombre premier sûr comme nous l'avons sélectionné, alors `P-1` n'aura que les facteurs 1, 2, `(P-1)/2` et `P-1`. Puisque `P` > 7, nous savons que 3 est relativement premier à `P-1`, donc `w=3` satisfait la proposition ci-dessus. + +## Algorithme d'évaluation basé sur un cache plus efficace {#cache-based-evaluation} + +```python +def quick_calc(params, seed, p): + cache = produce_dag(params, seed, params["cache_size"]) + return quick_calc_cached(cache, params, p) + +def quick_calc_cached(cache, params, p): + P = params["P"] + if p < len(cache): + return cache[p] + else: + x = pow(cache[0], p + 1, P) + for _ in range(params["k"]): + x ^= quick_calc_cached(cache, params, x % p) + return pow(x, params["w"], P) + +def quick_hashimoto(seed, dagsize, params, header, nonce): + cache = produce_dag(params, seed, params["cache_size"]) + return quick_hashimoto_cached(cache, dagsize, params, header, nonce) + +def quick_hashimoto_cached(cache, dagsize, params, header, nonce): + m = dagsize // 2 + mask = 2**64 - 1 + mix = sha3(encode_int(nonce) + header) + for _ in range(params["accesses"]): + mix ^= quick_calc_cached(cache, params, m + (mix & mask) % m) + return dbl_sha3(mix) +``` diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md new file mode 100644 index 00000000000..e31290eef6a --- /dev/null +++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md @@ -0,0 +1,1014 @@ +--- +title: Ethash +description: Un aperçu en détail de l'algorithme Ethash. +lang: fr +--- + + + Ethash était l'algorithme de minage par preuve de travail d'Ethereum. La preuve de travail est maintenant **arrêtée entièrement** et Ethereum est maintenant sécurisé en utilisant la preuve d'enjeu à la place. En savoir plus sur La Fusion, la preuve d'enjeu et la mise en jeu. Cette page n'a qu'un intérêt historique ! + + +[Ethash](https://github.com/ethereum/wiki/wiki/Ethash) est une version modifiée de l'algorithme [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto). La preuve de travail d'Ethash est une [mémoire solide](https://wikipedia.org/wiki/Memory-hard_function), qui était censée rendre l'algorithme ASIC plus résistant. Les Ethash ASIC ont finalement été développés, mais le minage via GPU restait encore une option viable jusqu’à ce que la preuve de travail soit désactivée. Ethash est toujours utilisé pour miner d'autres jetons sur des réseaux autres qu'Ethereum fonctionnant avec la preuve de travail. + +## Comment fonctionne Ethash ? {#how-does-ethash-work} + +La complexité de la mémoire est obtenue avec un algorithme de preuve de travail qui nécessite de choisir des sous-ensembles d'une ressource donnée dépendant de l'en-tête du nonce et du bloc. Cette ressource (quelques gigaoctets de taille) est appelée DAG. Le DAG change tous les 30 000 blocs, une fenêtre de 125 heures appelée une époque (soit environ 5,2 jours) et prend un certain temps à se générer. Comme le DAG ne dépend que de la taille du bloc, il peut être pré-généré, mais si ce n'est pas le cas, le client doit attendre la fin de ce processus pour produire un bloc. Si les clients ne génèrent pas et ne mettent pas en cache les DAG à l'avance, le réseau peut rencontrer un retard dans la création de blocs pour chaque transition d'epoch. Notez que le DAG n'a pas besoin d'être généré pour vérifier la preuve de travail essentiellement en permettant la vérification à la fois avec un CPU lent et avec une mémoire réduite. + +Le parcours habituel de l'algorithme est le suivant : + +1. Il existe une **graine** qui peut être calculée pour chaque bloc en scannant les en-têtes de bloc jusqu'à ce point. +2. À partir de la graine, on peut calculer un **cache pseudoaléatoire de 16 Mo**. Les clients légers stockent le cache. +3. À partir du cache, nous pouvons générer un **jeu de données 1 Go**, avec la propriété que chaque élément du jeu de données ne dépend que d'un petit nombre d'éléments du cache. Les clients et les mineurs au complet stockent le jeu de données. Le jeu de données croît linéairement avec le temps. +4. Le minage consiste à saisir des tranches aléatoires de l'ensemble des données et à les hacher ensemble. La vérification peut être faite avec peu de mémoire en utilisant le cache pour régénérer les morceaux spécifiques du jeu de données dont vous avez besoin, ainsi, vous avez uniquement besoin de stocker le cache. + +Le grand ensemble de données est mis à jour une fois tous les 30 000 blocs, de sorte que la grande majorité des efforts d'un mineur sera de lire l'ensemble des données, et non d'y apporter des modifications. + +## Définitions {#definitions} + +Nous utilisons les définitions suivantes : + +``` +WORD_BYTES = 4 # bytes in word +DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis +DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch +CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis +CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch +CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache +EPOCH_LENGTH = 30000 # blocks per epoch +MIX_BYTES = 128 # width of mix +HASH_BYTES = 64 # hash length in bytes +DATASET_PARENTS = 256 # number of parents of each dataset element +CACHE_ROUNDS = 3 # number of rounds in cache production +ACCESSES = 64 # number of accesses in hashimoto loop +``` + +### L'utilisation de 'SHA3' {#sha3} + +Le développement d'Ethereum a coïncidé avec le développement de la norme SHA3, et le processus de normes a réalisé un changement tardif dans le remplissage de l'algorithme de hachage finalisé de sorte que les hachages Ethereum "sha3_256" et "sha3_512" ne soient pas des hashs sha3 standard, mais une variante appelée souvent « Keccak-256 » et « Keccak-512 » dans d'autres contextes. Voir la discussion en exemple [ici](https://eips.ethereum.org/EIPS-1803), [ici](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use), ou [ici](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057). + +Veuillez garder cela à l'esprit, car les hachages « sha3 » sont mentionnés dans la description de l'algorithme ci-dessous. + +## Paramètres {#parameters} + +Les paramètres du cache et du jeu de données d'Ethash dépendent du numéro du bloc. La taille du cache et de la taille de l'ensemble des données augmentent linéairement ; cependant, nous prenons toujours le nombre premier le plus haut en dessous du seuil de croissance linéaire afin de réduire le risque de régularités accidentelles conduisant à un comportement cyclique. + +```python +def get_cache_size(block_number): + sz = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number // EPOCH_LENGTH) + sz -= HASH_BYTES + while not isprime(sz / HASH_BYTES): + sz -= 2 * HASH_BYTES + return sz + +def get_full_size(block_number): + sz = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number // EPOCH_LENGTH) + sz -= MIX_BYTES + while not isprime(sz / MIX_BYTES): + sz -= 2 * MIX_BYTES + return sz +``` + +Les tables de jeu de données et les valeurs de taille de cache sont fournies dans l'annexe. + +## Génération de cache {#cache-generation} + +Maintenant, nous spécifions la fonction pour produire un cache : + +```python +def mkcache(cache_size, seed): + n = cache_size // HASH_BYTES + + # Sequentially produce the initial dataset + o = [sha3_512(seed)] + for i in range(1, n): + o.append(sha3_512(o[-1])) + + # Use a low-round version of randmemohash + for _ in range(CACHE_ROUNDS): + for i in range(n): + v = o[i][0] % n + o[i] = sha3_512(map(xor, o[(i-1+n) % n], o[v])) + + return o +``` + +Le processus de production du cache implique d'abord le remplissage séquentiel de 32 Mo de mémoire, effectuant alors deux passes de l'algorithme _RandMemoHash_ de Sergio Demian Lerner à partir de [_Strict Memory Hashing Functions_ (2014)](http://www.hashcash.org/papers/memohash.pdf). La sortie est un ensemble de valeurs de 524288 de 64 octets. + +## Fonction d'agrégation de données {#date-aggregation-function} + +Nous utilisons un algorithme inspiré du [hachage FNV](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) dans certains cas comme un substitut non associatif pour XOR. Notez que nous multiplions le premier par l'entrée 32 bits, contrairement à la spécification FNV-1 qui multiplie le premier avec un octet à son tour. + +```python +FNV_PRIME = 0x01000193 + +def fnv(v1, v2): + return ((v1 * FNV_PRIME) ^ v2) % 2**32 +``` + +Veuillez noter que même le papier jaune spécifie fnv comme v1\*(FNV_PRIME ^ v2), toutes les implémentations actuelles utilisent systématiquement la définition ci-dessus. + +## Calcul du jeu de données complet {#full-dataset-calculation} + +Chaque élément de 64 octets dans le jeu de données complet de 1 Go est calculé comme suit : + +```python +def calc_dataset_item(cache, i): + n = len(cache) + r = HASH_BYTES // WORD_BYTES + # initialize the mix + mix = copy.copy(cache[i % n]) + mix[0] ^= i + mix = sha3_512(mix) + # fnv it with a lot of random cache nodes based on i + for j in range(DATASET_PARENTS): + cache_index = fnv(i ^ j, mix[j % r]) + mix = map(fnv, mix, cache[cache_index % n]) + return sha3_512(mix) +``` + +Essentiellement, nous combinons des données à partir de 256 nœuds de cache sélectionnés de façon pseudologique, et de hachage pour calculer le noeud de l'ensemble de données. L'ensemble du jeu de données est ensuite généré par : + +```python +def calc_dataset(full_size, cache): + return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)] +``` + +## Boucle principale {#main-loop} + +Maintenant, nous spécifions la boucle principale « hashimoto », où nous agrégeons les données du jeu de données complet, afin de produire notre valeur finale pour un en-tête et un nonce. Dans le code ci-dessous, `header` représente le _hachage_ SHA3-256 de la représentation RLP d'un en-tête de bloc _tronqué_, qui est d'un en-tête excluant les champs **mixHash** et **nonce**. `nonce` constitue les huit octets d'un entier 64 bits non signé dans un ordre big-endian. Ainsi `nonce[::-1]` est la représentation de huit octets little-endian de cette valeur : + +```python +def hashimoto(header, nonce, full_size, dataset_lookup): + n = full_size / HASH_BYTES + w = MIX_BYTES // WORD_BYTES + mixhashes = MIX_BYTES / HASH_BYTES + # combine header+nonce into a 64 byte seed + s = sha3_512(header + nonce[::-1]) + # start the mix with replicated s + mix = [] + for _ in range(MIX_BYTES / HASH_BYTES): + mix.extend(s) + # mix in random dataset nodes + for i in range(ACCESSES): + p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes + newdata = [] + for j in range(MIX_BYTES / HASH_BYTES): + newdata.extend(dataset_lookup(p + j)) + mix = map(fnv, mix, newdata) + # compress mix + cmix = [] + for i in range(0, len(mix), 4): + cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3])) + return { + "mix digest": serialize_hash(cmix), + "result": serialize_hash(sha3_256(s+cmix)) + } + +def hashimoto_light(full_size, cache, header, nonce): + return hashimoto(header, nonce, full_size, lambda x: calc_dataset_item(cache, x)) + +def hashimoto_full(full_size, dataset, header, nonce): + return hashimoto(header, nonce, full_size, lambda x: dataset[x]) +``` + +Essentiellement, nous maintenons un « mix » de 128 octets de taille, et récupérons séquentiellement 128 octets du jeu de données complet et utilisons la fonction `fnv` à des fins de combinaison avec le mix. 128 octets d'accès séquentiel sont utilisés de sorte que chaque tour de l'algorithme récupère toujours une page complète de la RAM. Minimiser le tampon de lecture de la traduction loupe ce que l'ASIC serait théoriquement en mesure d'éviter. + +Si la sortie de cet algorithme est en dessous de la cible souhaitée, alors le nonce est valide. Notez que l'application supplémentaire de `sha3_256` à la fin garantit qu'il existe un nonce intermédiaire qui peut être fourni pour prouver qu'au moins une petite quantité de travail a été faite ; cette vérification externe rapide de PoW peut être utilisée à des fins anti-DDoS. Cela sert également à fournir une assurance statistique que le résultat est un nombre non biaisé de 256 bits. + +## Minage {#mining} + +L'algorithme de minage est défini comme suit : + +```python +def mine(full_size, dataset, header, difficulty): + # zero-pad target to compare with hash on the same digit + target = zpad(encode_int(2**256 // difficulty), 64)[::-1] + from random import randint + nonce = randint(0, 2**64) + while hashimoto_full(full_size, dataset, header, nonce) > target: + nonce = (nonce + 1) % 2**64 + return nonce +``` + +## Définition du hachage de la graine {#seed-hash} + +Afin de calculer le hachage de la graine qui serait utilisé pour miner au-dessus d'un bloc donné, nous utilisons l'algorithme suivant : + +```python + def get_seedhash(block): + s = '\x00' * 32 + for i in range(block.number // EPOCH_LENGTH): + s = serialize_hash(sha3_256(s)) + return s +``` + +Notez que pour un minage et une vérification en douceur, nous recommandons de calculer au préalable les futures semences et les jeux de données dans un fil séparé. + +## Complément d'information {#further-reading} + +_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ + +## Annexe {#appendix} + +Le code suivant devrait être préfixé si vous souhaitez exécuter la spécification python ci-dessus en tant que code. + +```python +import sha3, copy + +# Assumes little endian bit ordering (same as Intel architectures) +def decode_int(s): + return int(s[::-1].encode('hex'), 16) if s else 0 + +def encode_int(s): + a = "%x" % s + return '' if s == 0 else ('0' * (len(a) % 2) + a).decode('hex')[::-1] + +def zpad(s, length): + return s + '\x00' * max(0, length - len(s)) + +def serialize_hash(h): + return ''.join([zpad(encode_int(x), 4) for x in h]) + +def deserialize_hash(h): + return [decode_int(h[i:i+WORD_BYTES]) for i in range(0, len(h), WORD_BYTES)] + +def hash_words(h, sz, x): + if isinstance(x, list): + x = serialize_hash(x) + y = h(x) + return deserialize_hash(y) + +def serialize_cache(ds): + return ''.join([serialize_hash(h) for h in ds]) + +serialize_dataset = serialize_cache + +# sha3 hash function, outputs 64 bytes +def sha3_512(x): + return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x) + +def sha3_256(x): + return hash_words(lambda v: sha3.sha3_256(v).digest(), 32, x) + +def xor(a, b): + return a ^ b + +def isprime(x): + for i in range(2, int(x**0.5)): + if x % i == 0: + return False + return True +``` + +### Tailles des données {#data-sizes} + +Les tables de recherche suivantes fournissent environ 2048 epochs tabulées de la taille des données et de la taille des caches. + +```python +def get_datasize(block_number): + return data_sizes[block_number // EPOCH_LENGTH] + +def get_cachesize(block_number): + return cache_sizes[block_number // EPOCH_LENGTH] + +data_sizes = [ +1073739904, 1082130304, 1090514816, 1098906752, 1107293056, +1115684224, 1124070016, 1132461952, 1140849536, 1149232768, +1157627776, 1166013824, 1174404736, 1182786944, 1191180416, +1199568512, 1207958912, 1216345216, 1224732032, 1233124736, +1241513344, 1249902464, 1258290304, 1266673792, 1275067264, +1283453312, 1291844992, 1300234112, 1308619904, 1317010048, +1325397376, 1333787776, 1342176128, 1350561664, 1358954368, +1367339392, 1375731584, 1384118144, 1392507008, 1400897408, +1409284736, 1417673344, 1426062464, 1434451072, 1442839168, +1451229056, 1459615616, 1468006016, 1476394112, 1484782976, +1493171584, 1501559168, 1509948032, 1518337664, 1526726528, +1535114624, 1543503488, 1551892096, 1560278656, 1568669056, +1577056384, 1585446272, 1593831296, 1602219392, 1610610304, +1619000192, 1627386752, 1635773824, 1644164224, 1652555648, +1660943488, 1669332608, 1677721216, 1686109312, 1694497664, +1702886272, 1711274624, 1719661184, 1728047744, 1736434816, +1744829056, 1753218944, 1761606272, 1769995904, 1778382464, +1786772864, 1795157888, 1803550592, 1811937664, 1820327552, +1828711552, 1837102976, 1845488768, 1853879936, 1862269312, +1870656896, 1879048064, 1887431552, 1895825024, 1904212096, +1912601216, 1920988544, 1929379456, 1937765504, 1946156672, +1954543232, 1962932096, 1971321728, 1979707264, 1988093056, +1996487552, 2004874624, 2013262208, 2021653888, 2030039936, +2038430848, 2046819968, 2055208576, 2063596672, 2071981952, +2080373632, 2088762752, 2097149056, 2105539712, 2113928576, +2122315136, 2130700672, 2139092608, 2147483264, 2155872128, +2164257664, 2172642176, 2181035392, 2189426048, 2197814912, +2206203008, 2214587264, 2222979712, 2231367808, 2239758208, +2248145024, 2256527744, 2264922752, 2273312128, 2281701248, +2290086272, 2298476672, 2306867072, 2315251072, 2323639168, +2332032128, 2340420224, 2348808064, 2357196416, 2365580416, +2373966976, 2382363008, 2390748544, 2399139968, 2407530368, +2415918976, 2424307328, 2432695424, 2441084288, 2449472384, +2457861248, 2466247808, 2474637184, 2483026816, 2491414144, +2499803776, 2508191872, 2516582272, 2524970368, 2533359232, +2541743488, 2550134144, 2558525056, 2566913408, 2575301504, +2583686528, 2592073856, 2600467328, 2608856192, 2617240448, +2625631616, 2634022016, 2642407552, 2650796416, 2659188352, +2667574912, 2675965312, 2684352896, 2692738688, 2701130624, +2709518464, 2717907328, 2726293376, 2734685056, 2743073152, +2751462016, 2759851648, 2768232832, 2776625536, 2785017728, +2793401984, 2801794432, 2810182016, 2818571648, 2826959488, +2835349376, 2843734144, 2852121472, 2860514432, 2868900992, +2877286784, 2885676928, 2894069632, 2902451584, 2910843008, +2919234688, 2927622784, 2936011648, 2944400768, 2952789376, +2961177728, 2969565568, 2977951616, 2986338944, 2994731392, +3003120256, 3011508352, 3019895936, 3028287104, 3036675968, +3045063808, 3053452928, 3061837696, 3070228352, 3078615424, +3087003776, 3095394944, 3103782272, 3112173184, 3120562048, +3128944768, 3137339264, 3145725056, 3154109312, 3162505088, +3170893184, 3179280256, 3187669376, 3196056704, 3204445568, +3212836736, 3221224064, 3229612928, 3238002304, 3246391168, +3254778496, 3263165824, 3271556224, 3279944576, 3288332416, +3296719232, 3305110912, 3313500032, 3321887104, 3330273152, +3338658944, 3347053184, 3355440512, 3363827072, 3372220288, +3380608384, 3388997504, 3397384576, 3405774208, 3414163072, +3422551936, 3430937984, 3439328384, 3447714176, 3456104576, +3464493952, 3472883584, 3481268864, 3489655168, 3498048896, +3506434432, 3514826368, 3523213952, 3531603584, 3539987072, +3548380288, 3556763264, 3565157248, 3573545344, 3581934464, +3590324096, 3598712704, 3607098752, 3615488384, 3623877248, +3632265856, 3640646528, 3649043584, 3657430144, 3665821568, +3674207872, 3682597504, 3690984832, 3699367808, 3707764352, +3716152448, 3724541056, 3732925568, 3741318016, 3749706368, +3758091136, 3766481536, 3774872704, 3783260032, 3791650432, +3800036224, 3808427648, 3816815488, 3825204608, 3833592704, +3841981568, 3850370432, 3858755968, 3867147904, 3875536256, +3883920512, 3892313728, 3900702592, 3909087872, 3917478784, +3925868416, 3934256512, 3942645376, 3951032192, 3959422336, +3967809152, 3976200064, 3984588416, 3992974976, 4001363584, +4009751168, 4018141312, 4026530432, 4034911616, 4043308928, +4051695488, 4060084352, 4068472448, 4076862848, 4085249408, +4093640576, 4102028416, 4110413696, 4118805632, 4127194496, +4135583104, 4143971968, 4152360832, 4160746112, 4169135744, +4177525888, 4185912704, 4194303616, 4202691968, 4211076736, +4219463552, 4227855488, 4236246656, 4244633728, 4253022848, +4261412224, 4269799808, 4278184832, 4286578048, 4294962304, +4303349632, 4311743104, 4320130432, 4328521088, 4336909184, +4345295488, 4353687424, 4362073472, 4370458496, 4378852736, +4387238528, 4395630208, 4404019072, 4412407424, 4420790656, +4429182848, 4437571456, 4445962112, 4454344064, 4462738048, +4471119232, 4479516544, 4487904128, 4496289664, 4504682368, +4513068416, 4521459584, 4529846144, 4538232704, 4546619776, +4555010176, 4563402112, 4571790208, 4580174464, 4588567936, +4596957056, 4605344896, 4613734016, 4622119808, 4630511488, +4638898816, 4647287936, 4655675264, 4664065664, 4672451968, +4680842624, 4689231488, 4697620352, 4706007424, 4714397056, +4722786176, 4731173248, 4739562368, 4747951744, 4756340608, +4764727936, 4773114496, 4781504384, 4789894784, 4798283648, +4806667648, 4815059584, 4823449472, 4831835776, 4840226176, +4848612224, 4857003392, 4865391488, 4873780096, 4882169728, +4890557312, 4898946944, 4907333248, 4915722368, 4924110976, +4932499328, 4940889728, 4949276032, 4957666432, 4966054784, +4974438016, 4982831488, 4991221376, 4999607168, 5007998848, +5016386432, 5024763776, 5033164672, 5041544576, 5049941888, +5058329728, 5066717056, 5075107456, 5083494272, 5091883904, +5100273536, 5108662144, 5117048192, 5125436032, 5133827456, +5142215296, 5150605184, 5158993024, 5167382144, 5175769472, +5184157568, 5192543872, 5200936064, 5209324928, 5217711232, +5226102656, 5234490496, 5242877312, 5251263872, 5259654016, +5268040832, 5276434304, 5284819328, 5293209728, 5301598592, +5309986688, 5318374784, 5326764416, 5335151488, 5343542144, +5351929472, 5360319872, 5368706944, 5377096576, 5385484928, +5393871232, 5402263424, 5410650496, 5419040384, 5427426944, +5435816576, 5444205952, 5452594816, 5460981376, 5469367936, +5477760896, 5486148736, 5494536832, 5502925952, 5511315328, +5519703424, 5528089984, 5536481152, 5544869504, 5553256064, +5561645696, 5570032768, 5578423936, 5586811264, 5595193216, +5603585408, 5611972736, 5620366208, 5628750464, 5637143936, +5645528192, 5653921408, 5662310272, 5670694784, 5679082624, +5687474048, 5695864448, 5704251008, 5712641408, 5721030272, +5729416832, 5737806208, 5746194304, 5754583936, 5762969984, +5771358592, 5779748224, 5788137856, 5796527488, 5804911232, +5813300608, 5821692544, 5830082176, 5838468992, 5846855552, +5855247488, 5863636096, 5872024448, 5880411008, 5888799872, +5897186432, 5905576832, 5913966976, 5922352768, 5930744704, +5939132288, 5947522432, 5955911296, 5964299392, 5972688256, +5981074304, 5989465472, 5997851008, 6006241408, 6014627968, +6023015552, 6031408256, 6039796096, 6048185216, 6056574848, +6064963456, 6073351808, 6081736064, 6090128768, 6098517632, +6106906496, 6115289216, 6123680896, 6132070016, 6140459648, +6148849024, 6157237376, 6165624704, 6174009728, 6182403712, +6190792064, 6199176064, 6207569792, 6215952256, 6224345216, +6232732544, 6241124224, 6249510272, 6257899136, 6266287744, +6274676864, 6283065728, 6291454336, 6299843456, 6308232064, +6316620928, 6325006208, 6333395584, 6341784704, 6350174848, +6358562176, 6366951296, 6375337856, 6383729536, 6392119168, +6400504192, 6408895616, 6417283456, 6425673344, 6434059136, +6442444672, 6450837376, 6459223424, 6467613056, 6476004224, +6484393088, 6492781952, 6501170048, 6509555072, 6517947008, +6526336384, 6534725504, 6543112832, 6551500672, 6559888768, +6568278656, 6576662912, 6585055616, 6593443456, 6601834112, +6610219648, 6618610304, 6626999168, 6635385472, 6643777408, +6652164224, 6660552832, 6668941952, 6677330048, 6685719424, +6694107776, 6702493568, 6710882176, 6719274112, 6727662976, +6736052096, 6744437632, 6752825984, 6761213824, 6769604224, +6777993856, 6786383488, 6794770816, 6803158144, 6811549312, +6819937664, 6828326528, 6836706176, 6845101696, 6853491328, +6861880448, 6870269312, 6878655104, 6887046272, 6895433344, +6903822208, 6912212864, 6920596864, 6928988288, 6937377152, +6945764992, 6954149248, 6962544256, 6970928768, 6979317376, +6987709312, 6996093824, 7004487296, 7012875392, 7021258624, +7029652352, 7038038912, 7046427776, 7054818944, 7063207808, +7071595136, 7079980928, 7088372608, 7096759424, 7105149824, +7113536896, 7121928064, 7130315392, 7138699648, 7147092352, +7155479168, 7163865728, 7172249984, 7180648064, 7189036672, +7197424768, 7205810816, 7214196608, 7222589824, 7230975104, +7239367552, 7247755904, 7256145536, 7264533376, 7272921472, +7281308032, 7289694848, 7298088832, 7306471808, 7314864512, +7323253888, 7331643008, 7340029568, 7348419712, 7356808832, +7365196672, 7373585792, 7381973888, 7390362752, 7398750592, +7407138944, 7415528576, 7423915648, 7432302208, 7440690304, +7449080192, 7457472128, 7465860992, 7474249088, 7482635648, +7491023744, 7499412608, 7507803008, 7516192384, 7524579968, +7532967296, 7541358464, 7549745792, 7558134656, 7566524032, +7574912896, 7583300992, 7591690112, 7600075136, 7608466816, +7616854912, 7625244544, 7633629824, 7642020992, 7650410368, +7658794112, 7667187328, 7675574912, 7683961984, 7692349568, +7700739712, 7709130368, 7717519232, 7725905536, 7734295424, +7742683264, 7751069056, 7759457408, 7767849088, 7776238208, +7784626816, 7793014912, 7801405312, 7809792128, 7818179968, +7826571136, 7834957184, 7843347328, 7851732352, 7860124544, +7868512384, 7876902016, 7885287808, 7893679744, 7902067072, +7910455936, 7918844288, 7927230848, 7935622784, 7944009344, +7952400256, 7960786048, 7969176704, 7977565312, 7985953408, +7994339968, 8002730368, 8011119488, 8019508096, 8027896192, +8036285056, 8044674688, 8053062272, 8061448832, 8069838464, +8078227328, 8086616704, 8095006592, 8103393664, 8111783552, +8120171392, 8128560256, 8136949376, 8145336704, 8153726848, +8162114944, 8170503296, 8178891904, 8187280768, 8195669632, +8204058496, 8212444544, 8220834176, 8229222272, 8237612672, +8246000768, 8254389376, 8262775168, 8271167104, 8279553664, +8287944064, 8296333184, 8304715136, 8313108352, 8321497984, +8329885568, 8338274432, 8346663296, 8355052928, 8363441536, +8371828352, 8380217984, 8388606592, 8396996224, 8405384576, +8413772672, 8422161536, 8430549376, 8438939008, 8447326592, +8455715456, 8464104832, 8472492928, 8480882048, 8489270656, +8497659776, 8506045312, 8514434944, 8522823808, 8531208832, +8539602304, 8547990656, 8556378752, 8564768384, 8573154176, +8581542784, 8589933952, 8598322816, 8606705024, 8615099264, +8623487872, 8631876992, 8640264064, 8648653952, 8657040256, +8665430656, 8673820544, 8682209152, 8690592128, 8698977152, +8707374464, 8715763328, 8724151424, 8732540032, 8740928384, +8749315712, 8757704576, 8766089344, 8774480768, 8782871936, +8791260032, 8799645824, 8808034432, 8816426368, 8824812928, +8833199488, 8841591424, 8849976448, 8858366336, 8866757248, +8875147136, 8883532928, 8891923328, 8900306816, 8908700288, +8917088384, 8925478784, 8933867392, 8942250368, 8950644608, +8959032704, 8967420544, 8975809664, 8984197504, 8992584064, +9000976256, 9009362048, 9017752448, 9026141312, 9034530688, +9042917504, 9051307904, 9059694208, 9068084864, 9076471424, +9084861824, 9093250688, 9101638528, 9110027648, 9118416512, +9126803584, 9135188096, 9143581312, 9151969664, 9160356224, +9168747136, 9177134464, 9185525632, 9193910144, 9202302848, +9210690688, 9219079552, 9227465344, 9235854464, 9244244864, +9252633472, 9261021824, 9269411456, 9277799296, 9286188928, +9294574208, 9302965888, 9311351936, 9319740032, 9328131968, +9336516736, 9344907392, 9353296768, 9361685888, 9370074752, +9378463616, 9386849408, 9395239808, 9403629184, 9412016512, +9420405376, 9428795008, 9437181568, 9445570688, 9453960832, +9462346624, 9470738048, 9479121536, 9487515008, 9495903616, +9504289664, 9512678528, 9521067904, 9529456256, 9537843584, +9546233728, 9554621312, 9563011456, 9571398784, 9579788672, +9588178304, 9596567168, 9604954496, 9613343104, 9621732992, +9630121856, 9638508416, 9646898816, 9655283584, 9663675776, +9672061312, 9680449664, 9688840064, 9697230464, 9705617536, +9714003584, 9722393984, 9730772608, 9739172224, 9747561088, +9755945344, 9764338816, 9772726144, 9781116544, 9789503872, +9797892992, 9806282624, 9814670464, 9823056512, 9831439232, +9839833984, 9848224384, 9856613504, 9865000576, 9873391232, +9881772416, 9890162816, 9898556288, 9906940544, 9915333248, +9923721088, 9932108672, 9940496512, 9948888448, 9957276544, +9965666176, 9974048384, 9982441088, 9990830464, 9999219584, +10007602816, 10015996544, 10024385152, 10032774016, 10041163648, +10049548928, 10057940096, 10066329472, 10074717824, 10083105152, +10091495296, 10099878784, 10108272256, 10116660608, 10125049216, +10133437312, 10141825664, 10150213504, 10158601088, 10166991232, +10175378816, 10183766144, 10192157312, 10200545408, 10208935552, +10217322112, 10225712768, 10234099328, 10242489472, 10250876032, +10259264896, 10267656064, 10276042624, 10284429184, 10292820352, +10301209472, 10309598848, 10317987712, 10326375296, 10334763392, +10343153536, 10351541632, 10359930752, 10368318592, 10376707456, +10385096576, 10393484672, 10401867136, 10410262144, 10418647424, +10427039104, 10435425664, 10443810176, 10452203648, 10460589952, +10468982144, 10477369472, 10485759104, 10494147712, 10502533504, +10510923392, 10519313536, 10527702656, 10536091264, 10544478592, +10552867712, 10561255808, 10569642368, 10578032768, 10586423168, +10594805632, 10603200128, 10611588992, 10619976064, 10628361344, +10636754048, 10645143424, 10653531776, 10661920384, 10670307968, +10678696832, 10687086464, 10695475072, 10703863168, 10712246144, +10720639616, 10729026688, 10737414784, 10745806208, 10754190976, +10762581376, 10770971264, 10779356288, 10787747456, 10796135552, +10804525184, 10812915584, 10821301888, 10829692288, 10838078336, +10846469248, 10854858368, 10863247232, 10871631488, 10880023424, +10888412032, 10896799616, 10905188992, 10913574016, 10921964672, +10930352768, 10938742912, 10947132544, 10955518592, 10963909504, +10972298368, 10980687488, 10989074816, 10997462912, 11005851776, +11014241152, 11022627712, 11031017344, 11039403904, 11047793024, +11056184704, 11064570752, 11072960896, 11081343872, 11089737856, +11098128256, 11106514816, 11114904448, 11123293568, 11131680128, +11140065152, 11148458368, 11156845696, 11165236864, 11173624192, +11182013824, 11190402688, 11198790784, 11207179136, 11215568768, +11223957376, 11232345728, 11240734592, 11249122688, 11257511296, +11265899648, 11274285952, 11282675584, 11291065472, 11299452544, +11307842432, 11316231296, 11324616832, 11333009024, 11341395584, +11349782656, 11358172288, 11366560384, 11374950016, 11383339648, +11391721856, 11400117376, 11408504192, 11416893568, 11425283456, +11433671552, 11442061184, 11450444672, 11458837888, 11467226752, +11475611776, 11484003968, 11492392064, 11500780672, 11509169024, +11517550976, 11525944448, 11534335616, 11542724224, 11551111808, +11559500672, 11567890304, 11576277376, 11584667008, 11593056128, +11601443456, 11609830016, 11618221952, 11626607488, 11634995072, +11643387776, 11651775104, 11660161664, 11668552576, 11676940928, +11685330304, 11693718656, 11702106496, 11710496128, 11718882688, +11727273088, 11735660416, 11744050048, 11752437376, 11760824704, +11769216128, 11777604736, 11785991296, 11794381952, 11802770048, +11811157888, 11819548544, 11827932544, 11836324736, 11844713344, +11853100928, 11861486464, 11869879936, 11878268032, 11886656896, +11895044992, 11903433088, 11911822976, 11920210816, 11928600448, +11936987264, 11945375872, 11953761152, 11962151296, 11970543488, +11978928512, 11987320448, 11995708288, 12004095104, 12012486272, +12020875136, 12029255552, 12037652096, 12046039168, 12054429568, +12062813824, 12071206528, 12079594624, 12087983744, 12096371072, +12104759936, 12113147264, 12121534592, 12129924992, 12138314624, +12146703232, 12155091584, 12163481216, 12171864704, 12180255872, +12188643968, 12197034112, 12205424512, 12213811328, 12222199424, +12230590336, 12238977664, 12247365248, 12255755392, 12264143488, +12272531584, 12280920448, 12289309568, 12297694592, 12306086528, +12314475392, 12322865024, 12331253632, 12339640448, 12348029312, +12356418944, 12364805248, 12373196672, 12381580928, 12389969024, +12398357632, 12406750592, 12415138432, 12423527552, 12431916416, +12440304512, 12448692352, 12457081216, 12465467776, 12473859968, +12482245504, 12490636672, 12499025536, 12507411584, 12515801728, +12524190592, 12532577152, 12540966272, 12549354368, 12557743232, +12566129536, 12574523264, 12582911872, 12591299456, 12599688064, +12608074624, 12616463488, 12624845696, 12633239936, 12641631616, +12650019968, 12658407296, 12666795136, 12675183232, 12683574656, +12691960192, 12700350592, 12708740224, 12717128576, 12725515904, +12733906816, 12742295168, 12750680192, 12759071872, 12767460736, +12775848832, 12784236928, 12792626816, 12801014656, 12809404288, +12817789312, 12826181504, 12834568832, 12842954624, 12851345792, +12859732352, 12868122496, 12876512128, 12884901248, 12893289088, +12901672832, 12910067584, 12918455168, 12926842496, 12935232896, +12943620736, 12952009856, 12960396928, 12968786816, 12977176192, +12985563776, 12993951104, 13002341504, 13010730368, 13019115392, +13027506304, 13035895168, 13044272512, 13052673152, 13061062528, +13069446272, 13077838976, 13086227072, 13094613632, 13103000192, +13111393664, 13119782528, 13128157568, 13136559232, 13144945024, +13153329536, 13161724288, 13170111872, 13178502784, 13186884736, +13195279744, 13203667072, 13212057472, 13220445824, 13228832128, +13237221248, 13245610624, 13254000512, 13262388352, 13270777472, +13279166336, 13287553408, 13295943296, 13304331904, 13312719488, +13321108096, 13329494656, 13337885824, 13346274944, 13354663808, +13363051136, 13371439232, 13379825024, 13388210816, 13396605056, +13404995456, 13413380224, 13421771392, 13430159744, 13438546048, +13446937216, 13455326848, 13463708288, 13472103808, 13480492672, +13488875648, 13497269888, 13505657728, 13514045312, 13522435712, +13530824576, 13539210112, 13547599232, 13555989376, 13564379008, +13572766336, 13581154432, 13589544832, 13597932928, 13606320512, +13614710656, 13623097472, 13631477632, 13639874944, 13648264064, +13656652928, 13665041792, 13673430656, 13681818496, 13690207616, +13698595712, 13706982272, 13715373184, 13723762048, 13732150144, +13740536704, 13748926592, 13757316224, 13765700992, 13774090112, +13782477952, 13790869376, 13799259008, 13807647872, 13816036736, +13824425344, 13832814208, 13841202304, 13849591424, 13857978752, +13866368896, 13874754688, 13883145344, 13891533184, 13899919232, +13908311168, 13916692096, 13925085056, 13933473152, 13941866368, +13950253696, 13958643584, 13967032192, 13975417216, 13983807616, +13992197504, 14000582272, 14008973696, 14017363072, 14025752192, +14034137984, 14042528384, 14050918016, 14059301504, 14067691648, +14076083584, 14084470144, 14092852352, 14101249664, 14109635968, +14118024832, 14126407552, 14134804352, 14143188608, 14151577984, +14159968384, 14168357248, 14176741504, 14185127296, 14193521024, +14201911424, 14210301824, 14218685056, 14227067264, 14235467392, +14243855488, 14252243072, 14260630144, 14269021568, 14277409408, +14285799296, 14294187904, 14302571392, 14310961792, 14319353728, +14327738752, 14336130944, 14344518784, 14352906368, 14361296512, +14369685376, 14378071424, 14386462592, 14394848128, 14403230848, +14411627392, 14420013952, 14428402304, 14436793472, 14445181568, +14453569664, 14461959808, 14470347904, 14478737024, 14487122816, +14495511424, 14503901824, 14512291712, 14520677504, 14529064832, +14537456768, 14545845632, 14554234496, 14562618496, 14571011456, +14579398784, 14587789184, 14596172672, 14604564608, 14612953984, +14621341312, 14629724288, 14638120832, 14646503296, 14654897536, +14663284864, 14671675264, 14680061056, 14688447616, 14696835968, +14705228416, 14713616768, 14722003328, 14730392192, 14738784128, +14747172736, 14755561088, 14763947648, 14772336512, 14780725376, +14789110144, 14797499776, 14805892736, 14814276992, 14822670208, +14831056256, 14839444352, 14847836032, 14856222848, 14864612992, +14872997504, 14881388672, 14889775744, 14898165376, 14906553472, +14914944896, 14923329664, 14931721856, 14940109696, 14948497024, +14956887424, 14965276544, 14973663616, 14982053248, 14990439808, +14998830976, 15007216768, 15015605888, 15023995264, 15032385152, +15040768384, 15049154944, 15057549184, 15065939072, 15074328448, +15082715008, 15091104128, 15099493504, 15107879296, 15116269184, +15124659584, 15133042304, 15141431936, 15149824384, 15158214272, +15166602368, 15174991232, 15183378304, 15191760512, 15200154496, +15208542592, 15216931712, 15225323392, 15233708416, 15242098048, +15250489216, 15258875264, 15267265408, 15275654528, 15284043136, +15292431488, 15300819584, 15309208192, 15317596544, 15325986176, +15334374784, 15342763648, 15351151744, 15359540608, 15367929728, +15376318336, 15384706432, 15393092992, 15401481856, 15409869952, +15418258816, 15426649984, 15435037568, 15443425664, 15451815296, +15460203392, 15468589184, 15476979328, 15485369216, 15493755776, +15502146944, 15510534272, 15518924416, 15527311232, 15535699072, +15544089472, 15552478336, 15560866688, 15569254528, 15577642624, +15586031488, 15594419072, 15602809472, 15611199104, 15619586432, +15627975296, 15636364928, 15644753792, 15653141888, 15661529216, +15669918848, 15678305152, 15686696576, 15695083136, 15703474048, +15711861632, 15720251264, 15728636288, 15737027456, 15745417088, +15753804928, 15762194048, 15770582656, 15778971008, 15787358336, +15795747712, 15804132224, 15812523392, 15820909696, 15829300096, +15837691264, 15846071936, 15854466944, 15862855808, 15871244672, +15879634816, 15888020608, 15896409728, 15904799104, 15913185152, +15921577088, 15929966464, 15938354816, 15946743424, 15955129472, +15963519872, 15971907968, 15980296064, 15988684928, 15997073024, +16005460864, 16013851264, 16022241152, 16030629248, 16039012736, +16047406976, 16055794816, 16064181376, 16072571264, 16080957824, +16089346688, 16097737856, 16106125184, 16114514816, 16122904192, +16131292544, 16139678848, 16148066944, 16156453504, 16164839552, +16173236096, 16181623424, 16190012032, 16198401152, 16206790528, +16215177344, 16223567744, 16231956352, 16240344704, 16248731008, +16257117824, 16265504384, 16273898624, 16282281856, 16290668672, +16299064192, 16307449216, 16315842176, 16324230016, 16332613504, +16341006464, 16349394304, 16357783168, 16366172288, 16374561664, +16382951296, 16391337856, 16399726208, 16408116352, 16416505472, +16424892032, 16433282176, 16441668224, 16450058624, 16458448768, +16466836864, 16475224448, 16483613056, 16492001408, 16500391808, +16508779648, 16517166976, 16525555328, 16533944192, 16542330752, +16550719616, 16559110528, 16567497088, 16575888512, 16584274816, +16592665472, 16601051008, 16609442944, 16617832064, 16626218624, +16634607488, 16642996096, 16651385728, 16659773824, 16668163712, +16676552576, 16684938112, 16693328768, 16701718144, 16710095488, +16718492288, 16726883968, 16735272832, 16743661184, 16752049792, +16760436608, 16768827008, 16777214336, 16785599104, 16793992832, +16802381696, 16810768768, 16819151744, 16827542656, 16835934848, +16844323712, 16852711552, 16861101952, 16869489536, 16877876864, +16886265728, 16894653056, 16903044736, 16911431296, 16919821696, +16928207488, 16936592768, 16944987776, 16953375616, 16961763968, +16970152832, 16978540928, 16986929536, 16995319168, 17003704448, +17012096896, 17020481152, 17028870784, 17037262208, 17045649536, +17054039936, 17062426496, 17070814336, 17079205504, 17087592064, +17095978112, 17104369024, 17112759424, 17121147776, 17129536384, +17137926016, 17146314368, 17154700928, 17163089792, 17171480192, +17179864192, 17188256896, 17196644992, 17205033856, 17213423488, +17221811072, 17230198912, 17238588032, 17246976896, 17255360384, +17263754624, 17272143232, 17280530048, 17288918912, 17297309312, +17305696384, 17314085504, 17322475136, 17330863744, 17339252096, +17347640192, 17356026496, 17364413824, 17372796544, 17381190016, +17389583488, 17397972608, 17406360704, 17414748544, 17423135872, +17431527296, 17439915904, 17448303232, 17456691584, 17465081728, +17473468288, 17481857408, 17490247552, 17498635904, 17507022464, +17515409024, 17523801728, 17532189824, 17540577664, 17548966016, +17557353344, 17565741184, 17574131584, 17582519168, 17590907008, +17599296128, 17607687808, 17616076672, 17624455808, 17632852352, +17641238656, 17649630848, 17658018944, 17666403968, 17674794112, +17683178368, 17691573376, 17699962496, 17708350592, 17716739968, +17725126528, 17733517184, 17741898112, 17750293888, 17758673024, +17767070336, 17775458432, 17783848832, 17792236928, 17800625536, +17809012352, 17817402752, 17825785984, 17834178944, 17842563968, +17850955648, 17859344512, 17867732864, 17876119424, 17884511872, +17892900224, 17901287296, 17909677696, 17918058112, 17926451072, +17934843776, 17943230848, 17951609216, 17960008576, 17968397696, +17976784256, 17985175424, 17993564032, 18001952128, 18010339712, +18018728576, 18027116672, 18035503232, 18043894144, 18052283264, +18060672128, 18069056384, 18077449856, 18085837184, 18094225792, +18102613376, 18111004544, 18119388544, 18127781248, 18136170368, +18144558976, 18152947328, 18161336192, 18169724288, 18178108544, +18186498944, 18194886784, 18203275648, 18211666048, 18220048768, +18228444544, 18236833408, 18245220736] + +cache_sizes = [ +16776896, 16907456, 17039296, 17170112, 17301056, 17432512, 17563072, +17693888, 17824192, 17955904, 18087488, 18218176, 18349504, 18481088, +18611392, 18742336, 18874304, 19004224, 19135936, 19267264, 19398208, +19529408, 19660096, 19791424, 19922752, 20053952, 20184896, 20315968, +20446912, 20576576, 20709184, 20840384, 20971072, 21102272, 21233216, +21364544, 21494848, 21626816, 21757376, 21887552, 22019392, 22151104, +22281536, 22412224, 22543936, 22675264, 22806464, 22935872, 23068096, +23198272, 23330752, 23459008, 23592512, 23723968, 23854912, 23986112, +24116672, 24247616, 24378688, 24509504, 24640832, 24772544, 24903488, +25034432, 25165376, 25296704, 25427392, 25558592, 25690048, 25820096, +25951936, 26081728, 26214208, 26345024, 26476096, 26606656, 26737472, +26869184, 26998208, 27131584, 27262528, 27393728, 27523904, 27655744, +27786688, 27917888, 28049344, 28179904, 28311488, 28441792, 28573504, +28700864, 28835648, 28966208, 29096768, 29228608, 29359808, 29490752, +29621824, 29752256, 29882816, 30014912, 30144448, 30273728, 30406976, +30538432, 30670784, 30799936, 30932672, 31063744, 31195072, 31325248, +31456192, 31588288, 31719232, 31850432, 31981504, 32110784, 32243392, +32372672, 32505664, 32636608, 32767808, 32897344, 33029824, 33160768, +33289664, 33423296, 33554368, 33683648, 33816512, 33947456, 34076992, +34208704, 34340032, 34471744, 34600256, 34734016, 34864576, 34993984, +35127104, 35258176, 35386688, 35518528, 35650624, 35782336, 35910976, +36044608, 36175808, 36305728, 36436672, 36568384, 36699968, 36830656, +36961984, 37093312, 37223488, 37355072, 37486528, 37617472, 37747904, +37879232, 38009792, 38141888, 38272448, 38403392, 38535104, 38660672, +38795584, 38925632, 39059264, 39190336, 39320768, 39452096, 39581632, +39713984, 39844928, 39974848, 40107968, 40238144, 40367168, 40500032, +40631744, 40762816, 40894144, 41023552, 41155904, 41286208, 41418304, +41547712, 41680448, 41811904, 41942848, 42073792, 42204992, 42334912, +42467008, 42597824, 42729152, 42860096, 42991552, 43122368, 43253696, +43382848, 43515712, 43646912, 43777088, 43907648, 44039104, 44170432, +44302144, 44433344, 44564288, 44694976, 44825152, 44956864, 45088448, +45219008, 45350464, 45481024, 45612608, 45744064, 45874496, 46006208, +46136768, 46267712, 46399424, 46529344, 46660672, 46791488, 46923328, +47053504, 47185856, 47316928, 47447872, 47579072, 47710144, 47839936, +47971648, 48103232, 48234176, 48365248, 48496192, 48627136, 48757312, +48889664, 49020736, 49149248, 49283008, 49413824, 49545152, 49675712, +49807168, 49938368, 50069056, 50200256, 50331584, 50462656, 50593472, +50724032, 50853952, 50986048, 51117632, 51248576, 51379904, 51510848, +51641792, 51773248, 51903296, 52035136, 52164032, 52297664, 52427968, +52557376, 52690112, 52821952, 52952896, 53081536, 53213504, 53344576, +53475776, 53608384, 53738816, 53870528, 54000832, 54131776, 54263744, +54394688, 54525248, 54655936, 54787904, 54918592, 55049152, 55181248, +55312064, 55442752, 55574336, 55705024, 55836224, 55967168, 56097856, +56228672, 56358592, 56490176, 56621888, 56753728, 56884928, 57015488, +57146816, 57278272, 57409216, 57540416, 57671104, 57802432, 57933632, +58064576, 58195264, 58326976, 58457408, 58588864, 58720192, 58849984, +58981696, 59113024, 59243456, 59375552, 59506624, 59637568, 59768512, +59897792, 60030016, 60161984, 60293056, 60423872, 60554432, 60683968, +60817216, 60948032, 61079488, 61209664, 61341376, 61471936, 61602752, +61733696, 61865792, 61996736, 62127808, 62259136, 62389568, 62520512, +62651584, 62781632, 62910784, 63045056, 63176128, 63307072, 63438656, +63569216, 63700928, 63831616, 63960896, 64093888, 64225088, 64355392, +64486976, 64617664, 64748608, 64879424, 65009216, 65142464, 65273792, +65402816, 65535424, 65666752, 65797696, 65927744, 66060224, 66191296, +66321344, 66453056, 66584384, 66715328, 66846656, 66977728, 67108672, +67239104, 67370432, 67501888, 67631296, 67763776, 67895104, 68026304, +68157248, 68287936, 68419264, 68548288, 68681408, 68811968, 68942912, +69074624, 69205568, 69337024, 69467584, 69599168, 69729472, 69861184, +69989824, 70122944, 70253888, 70385344, 70515904, 70647232, 70778816, +70907968, 71040832, 71171648, 71303104, 71432512, 71564992, 71695168, +71826368, 71958464, 72089536, 72219712, 72350144, 72482624, 72613568, +72744512, 72875584, 73006144, 73138112, 73268672, 73400128, 73530944, +73662272, 73793344, 73924544, 74055104, 74185792, 74316992, 74448832, +74579392, 74710976, 74841664, 74972864, 75102784, 75233344, 75364544, +75497024, 75627584, 75759296, 75890624, 76021696, 76152256, 76283072, +76414144, 76545856, 76676672, 76806976, 76937792, 77070016, 77200832, +77331392, 77462464, 77593664, 77725376, 77856448, 77987776, 78118336, +78249664, 78380992, 78511424, 78642496, 78773056, 78905152, 79033664, +79166656, 79297472, 79429568, 79560512, 79690816, 79822784, 79953472, +80084672, 80214208, 80346944, 80477632, 80608576, 80740288, 80870848, +81002048, 81133504, 81264448, 81395648, 81525952, 81657536, 81786304, +81919808, 82050112, 82181312, 82311616, 82443968, 82573376, 82705984, +82835776, 82967744, 83096768, 83230528, 83359552, 83491264, 83622464, +83753536, 83886016, 84015296, 84147776, 84277184, 84409792, 84540608, +84672064, 84803008, 84934336, 85065152, 85193792, 85326784, 85458496, +85589312, 85721024, 85851968, 85982656, 86112448, 86244416, 86370112, +86506688, 86637632, 86769344, 86900672, 87031744, 87162304, 87293632, +87424576, 87555392, 87687104, 87816896, 87947968, 88079168, 88211264, +88341824, 88473152, 88603712, 88735424, 88862912, 88996672, 89128384, +89259712, 89390272, 89521984, 89652544, 89783872, 89914816, 90045376, +90177088, 90307904, 90438848, 90569152, 90700096, 90832832, 90963776, +91093696, 91223744, 91356992, 91486784, 91618496, 91749824, 91880384, +92012224, 92143552, 92273344, 92405696, 92536768, 92666432, 92798912, +92926016, 93060544, 93192128, 93322816, 93453632, 93583936, 93715136, +93845056, 93977792, 94109504, 94240448, 94371776, 94501184, 94632896, +94764224, 94895552, 95023424, 95158208, 95287744, 95420224, 95550016, +95681216, 95811904, 95943872, 96075328, 96203584, 96337856, 96468544, +96599744, 96731072, 96860992, 96992576, 97124288, 97254848, 97385536, +97517248, 97647808, 97779392, 97910464, 98041408, 98172608, 98303168, +98434496, 98565568, 98696768, 98827328, 98958784, 99089728, 99220928, +99352384, 99482816, 99614272, 99745472, 99876416, 100007104, +100138048, 100267072, 100401088, 100529984, 100662592, 100791872, +100925248, 101056064, 101187392, 101317952, 101449408, 101580608, +101711296, 101841728, 101973824, 102104896, 102235712, 102366016, +102498112, 102628672, 102760384, 102890432, 103021888, 103153472, +103284032, 103415744, 103545152, 103677248, 103808576, 103939648, +104070976, 104201792, 104332736, 104462528, 104594752, 104725952, +104854592, 104988608, 105118912, 105247808, 105381184, 105511232, +105643072, 105774784, 105903296, 106037056, 106167872, 106298944, +106429504, 106561472, 106691392, 106822592, 106954304, 107085376, +107216576, 107346368, 107478464, 107609792, 107739712, 107872192, +108003136, 108131392, 108265408, 108396224, 108527168, 108657344, +108789568, 108920384, 109049792, 109182272, 109312576, 109444928, +109572928, 109706944, 109837888, 109969088, 110099648, 110230976, +110362432, 110492992, 110624704, 110755264, 110886208, 111017408, +111148864, 111279296, 111410752, 111541952, 111673024, 111803456, +111933632, 112066496, 112196416, 112328512, 112457792, 112590784, +112715968, 112852672, 112983616, 113114944, 113244224, 113376448, +113505472, 113639104, 113770304, 113901376, 114031552, 114163264, +114294592, 114425536, 114556864, 114687424, 114818624, 114948544, +115080512, 115212224, 115343296, 115473472, 115605184, 115736128, +115867072, 115997248, 116128576, 116260288, 116391488, 116522944, +116652992, 116784704, 116915648, 117046208, 117178304, 117308608, +117440192, 117569728, 117701824, 117833024, 117964096, 118094656, +118225984, 118357312, 118489024, 118617536, 118749632, 118882112, +119012416, 119144384, 119275328, 119406016, 119537344, 119668672, +119798464, 119928896, 120061376, 120192832, 120321728, 120454336, +120584512, 120716608, 120848192, 120979136, 121109056, 121241408, +121372352, 121502912, 121634752, 121764416, 121895744, 122027072, +122157632, 122289088, 122421184, 122550592, 122682944, 122813888, +122945344, 123075776, 123207488, 123338048, 123468736, 123600704, +123731264, 123861952, 123993664, 124124608, 124256192, 124386368, +124518208, 124649024, 124778048, 124911296, 125041088, 125173696, +125303744, 125432896, 125566912, 125696576, 125829056, 125958592, +126090304, 126221248, 126352832, 126483776, 126615232, 126746432, +126876608, 127008704, 127139392, 127270336, 127401152, 127532224, +127663552, 127794752, 127925696, 128055232, 128188096, 128319424, +128449856, 128581312, 128712256, 128843584, 128973632, 129103808, +129236288, 129365696, 129498944, 129629888, 129760832, 129892288, +130023104, 130154048, 130283968, 130416448, 130547008, 130678336, +130807616, 130939456, 131071552, 131202112, 131331776, 131464384, +131594048, 131727296, 131858368, 131987392, 132120256, 132250816, +132382528, 132513728, 132644672, 132774976, 132905792, 133038016, +133168832, 133299392, 133429312, 133562048, 133692992, 133823296, +133954624, 134086336, 134217152, 134348608, 134479808, 134607296, +134741056, 134872384, 135002944, 135134144, 135265472, 135396544, +135527872, 135659072, 135787712, 135921472, 136052416, 136182848, +136313792, 136444864, 136576448, 136707904, 136837952, 136970048, +137099584, 137232064, 137363392, 137494208, 137625536, 137755712, +137887424, 138018368, 138149824, 138280256, 138411584, 138539584, +138672832, 138804928, 138936128, 139066688, 139196864, 139328704, +139460032, 139590208, 139721024, 139852864, 139984576, 140115776, +140245696, 140376512, 140508352, 140640064, 140769856, 140902336, +141032768, 141162688, 141294016, 141426496, 141556544, 141687488, +141819584, 141949888, 142080448, 142212544, 142342336, 142474432, +142606144, 142736192, 142868288, 142997824, 143129408, 143258944, +143392448, 143523136, 143653696, 143785024, 143916992, 144045632, +144177856, 144309184, 144440768, 144570688, 144701888, 144832448, +144965056, 145096384, 145227584, 145358656, 145489856, 145620928, +145751488, 145883072, 146011456, 146144704, 146275264, 146407232, +146538176, 146668736, 146800448, 146931392, 147062336, 147193664, +147324224, 147455936, 147586624, 147717056, 147848768, 147979456, +148110784, 148242368, 148373312, 148503232, 148635584, 148766144, +148897088, 149028416, 149159488, 149290688, 149420224, 149551552, +149683136, 149814976, 149943616, 150076352, 150208064, 150338624, +150470464, 150600256, 150732224, 150862784, 150993088, 151125952, +151254976, 151388096, 151519168, 151649728, 151778752, 151911104, +152042944, 152174144, 152304704, 152435648, 152567488, 152698816, +152828992, 152960576, 153091648, 153222976, 153353792, 153484096, +153616192, 153747008, 153878336, 154008256, 154139968, 154270912, +154402624, 154533824, 154663616, 154795712, 154926272, 155057984, +155188928, 155319872, 155450816, 155580608, 155712064, 155843392, +155971136, 156106688, 156237376, 156367424, 156499264, 156630976, +156761536, 156892352, 157024064, 157155008, 157284416, 157415872, +157545536, 157677248, 157810496, 157938112, 158071744, 158203328, +158334656, 158464832, 158596288, 158727616, 158858048, 158988992, +159121216, 159252416, 159381568, 159513152, 159645632, 159776192, +159906496, 160038464, 160169536, 160300352, 160430656, 160563008, +160693952, 160822208, 160956352, 161086784, 161217344, 161349184, +161480512, 161611456, 161742272, 161873216, 162002752, 162135872, +162266432, 162397888, 162529216, 162660032, 162790976, 162922048, +163052096, 163184576, 163314752, 163446592, 163577408, 163707968, +163839296, 163969984, 164100928, 164233024, 164364224, 164494912, +164625856, 164756672, 164887616, 165019072, 165150016, 165280064, +165412672, 165543104, 165674944, 165805888, 165936832, 166067648, +166198336, 166330048, 166461248, 166591552, 166722496, 166854208, +166985408, 167116736, 167246656, 167378368, 167508416, 167641024, +167771584, 167903168, 168034112, 168164032, 168295744, 168427456, +168557632, 168688448, 168819136, 168951616, 169082176, 169213504, +169344832, 169475648, 169605952, 169738048, 169866304, 169999552, +170131264, 170262464, 170393536, 170524352, 170655424, 170782016, +170917696, 171048896, 171179072, 171310784, 171439936, 171573184, +171702976, 171835072, 171966272, 172097216, 172228288, 172359232, +172489664, 172621376, 172747712, 172883264, 173014208, 173144512, +173275072, 173407424, 173539136, 173669696, 173800768, 173931712, +174063424, 174193472, 174325696, 174455744, 174586816, 174718912, +174849728, 174977728, 175109696, 175242688, 175374272, 175504832, +175636288, 175765696, 175898432, 176028992, 176159936, 176291264, +176422592, 176552512, 176684864, 176815424, 176946496, 177076544, +177209152, 177340096, 177470528, 177600704, 177731648, 177864256, +177994816, 178126528, 178257472, 178387648, 178518464, 178650176, +178781888, 178912064, 179044288, 179174848, 179305024, 179436736, +179568448, 179698496, 179830208, 179960512, 180092608, 180223808, +180354752, 180485696, 180617152, 180748096, 180877504, 181009984, +181139264, 181272512, 181402688, 181532608, 181663168, 181795136, +181926592, 182057536, 182190016, 182320192, 182451904, 182582336, +182713792, 182843072, 182976064, 183107264, 183237056, 183368384, +183494848, 183631424, 183762752, 183893824, 184024768, 184154816, +184286656, 184417984, 184548928, 184680128, 184810816, 184941248, +185072704, 185203904, 185335616, 185465408, 185596352, 185727296, +185859904, 185989696, 186121664, 186252992, 186383552, 186514112, +186645952, 186777152, 186907328, 187037504, 187170112, 187301824, +187429184, 187562048, 187693504, 187825472, 187957184, 188087104, +188218304, 188349376, 188481344, 188609728, 188743616, 188874304, +189005248, 189136448, 189265088, 189396544, 189528128, 189660992, +189791936, 189923264, 190054208, 190182848, 190315072, 190447424, +190577984, 190709312, 190840768, 190971328, 191102656, 191233472, +191364032, 191495872, 191626816, 191758016, 191888192, 192020288, +192148928, 192282176, 192413504, 192542528, 192674752, 192805952, +192937792, 193068608, 193198912, 193330496, 193462208, 193592384, +193723456, 193854272, 193985984, 194116672, 194247232, 194379712, +194508352, 194641856, 194772544, 194900672, 195035072, 195166016, +195296704, 195428032, 195558592, 195690304, 195818176, 195952576, +196083392, 196214336, 196345792, 196476736, 196607552, 196739008, +196869952, 197000768, 197130688, 197262784, 197394368, 197523904, +197656384, 197787584, 197916608, 198049472, 198180544, 198310208, +198442432, 198573632, 198705088, 198834368, 198967232, 199097792, +199228352, 199360192, 199491392, 199621696, 199751744, 199883968, +200014016, 200146624, 200276672, 200408128, 200540096, 200671168, +200801984, 200933312, 201062464, 201194944, 201326144, 201457472, +201588544, 201719744, 201850816, 201981632, 202111552, 202244032, +202374464, 202505152, 202636352, 202767808, 202898368, 203030336, +203159872, 203292608, 203423296, 203553472, 203685824, 203816896, +203947712, 204078272, 204208192, 204341056, 204472256, 204603328, +204733888, 204864448, 204996544, 205125568, 205258304, 205388864, +205517632, 205650112, 205782208, 205913536, 206044736, 206176192, +206307008, 206434496, 206569024, 206700224, 206831168, 206961856, +207093056, 207223616, 207355328, 207486784, 207616832, 207749056, +207879104, 208010048, 208141888, 208273216, 208404032, 208534336, +208666048, 208796864, 208927424, 209059264, 209189824, 209321792, +209451584, 209582656, 209715136, 209845568, 209976896, 210106432, +210239296, 210370112, 210501568, 210630976, 210763712, 210894272, +211024832, 211156672, 211287616, 211418176, 211549376, 211679296, +211812032, 211942592, 212074432, 212204864, 212334016, 212467648, +212597824, 212727616, 212860352, 212991424, 213120832, 213253952, +213385024, 213515584, 213645632, 213777728, 213909184, 214040128, +214170688, 214302656, 214433728, 214564544, 214695232, 214826048, +214956992, 215089088, 215219776, 215350592, 215482304, 215613248, +215743552, 215874752, 216005312, 216137024, 216267328, 216399296, +216530752, 216661696, 216790592, 216923968, 217054528, 217183168, +217316672, 217448128, 217579072, 217709504, 217838912, 217972672, +218102848, 218233024, 218364736, 218496832, 218627776, 218759104, +218888896, 219021248, 219151936, 219281728, 219413056, 219545024, +219675968, 219807296, 219938624, 220069312, 220200128, 220331456, +220461632, 220592704, 220725184, 220855744, 220987072, 221117888, +221249216, 221378368, 221510336, 221642048, 221772736, 221904832, +222031808, 222166976, 222297536, 222428992, 222559936, 222690368, +222820672, 222953152, 223083968, 223213376, 223345984, 223476928, +223608512, 223738688, 223869376, 224001472, 224132672, 224262848, +224394944, 224524864, 224657344, 224788288, 224919488, 225050432, +225181504, 225312704, 225443776, 225574592, 225704768, 225834176, +225966784, 226097216, 226229824, 226360384, 226491712, 226623424, +226754368, 226885312, 227015104, 227147456, 227278528, 227409472, +227539904, 227669696, 227802944, 227932352, 228065216, 228196288, +228326464, 228457792, 228588736, 228720064, 228850112, 228981056, +229113152, 229243328, 229375936, 229505344, 229636928, 229769152, +229894976, 230030272, 230162368, 230292416, 230424512, 230553152, +230684864, 230816704, 230948416, 231079616, 231210944, 231342016, +231472448, 231603776, 231733952, 231866176, 231996736, 232127296, +232259392, 232388672, 232521664, 232652608, 232782272, 232914496, +233043904, 233175616, 233306816, 233438528, 233569984, 233699776, +233830592, 233962688, 234092224, 234221888, 234353984, 234485312, +234618304, 234749888, 234880832, 235011776, 235142464, 235274048, +235403456, 235535936, 235667392, 235797568, 235928768, 236057152, +236190272, 236322752, 236453312, 236583616, 236715712, 236846528, +236976448, 237108544, 237239104, 237371072, 237501632, 237630784, +237764416, 237895232, 238026688, 238157632, 238286912, 238419392, +238548032, 238681024, 238812608, 238941632, 239075008, 239206336, +239335232, 239466944, 239599168, 239730496, 239861312, 239992384, +240122816, 240254656, 240385856, 240516928, 240647872, 240779072, +240909632, 241040704, 241171904, 241302848, 241433408, 241565248, +241696192, 241825984, 241958848, 242088256, 242220224, 242352064, +242481856, 242611648, 242744896, 242876224, 243005632, 243138496, +243268672, 243400384, 243531712, 243662656, 243793856, 243924544, +244054592, 244187072, 244316608, 244448704, 244580032, 244710976, +244841536, 244972864, 245104448, 245233984, 245365312, 245497792, +245628736, 245759936, 245889856, 246021056, 246152512, 246284224, +246415168, 246545344, 246675904, 246808384, 246939584, 247070144, +247199552, 247331648, 247463872, 247593536, 247726016, 247857088, +247987648, 248116928, 248249536, 248380736, 248512064, 248643008, +248773312, 248901056, 249036608, 249167552, 249298624, 249429184, +249560512, 249692096, 249822784, 249954112, 250085312, 250215488, +250345792, 250478528, 250608704, 250739264, 250870976, 251002816, +251133632, 251263552, 251395136, 251523904, 251657792, 251789248, +251919424, 252051392, 252182464, 252313408, 252444224, 252575552, +252706624, 252836032, 252968512, 253099712, 253227584, 253361728, +253493056, 253623488, 253754432, 253885504, 254017216, 254148032, +254279488, 254410432, 254541376, 254672576, 254803264, 254933824, +255065792, 255196736, 255326528, 255458752, 255589952, 255721408, +255851072, 255983296, 256114624, 256244416, 256374208, 256507712, +256636096, 256768832, 256900544, 257031616, 257162176, 257294272, +257424448, 257555776, 257686976, 257818432, 257949632, 258079552, +258211136, 258342464, 258473408, 258603712, 258734656, 258867008, +258996544, 259127744, 259260224, 259391296, 259522112, 259651904, +259784384, 259915328, 260045888, 260175424, 260308544, 260438336, +260570944, 260700992, 260832448, 260963776, 261092672, 261226304, +261356864, 261487936, 261619648, 261750592, 261879872, 262011968, +262143424, 262274752, 262404416, 262537024, 262667968, 262799296, +262928704, 263061184, 263191744, 263322944, 263454656, 263585216, +263716672, 263847872, 263978944, 264108608, 264241088, 264371648, +264501184, 264632768, 264764096, 264895936, 265024576, 265158464, +265287488, 265418432, 265550528, 265681216, 265813312, 265943488, +266075968, 266206144, 266337728, 266468032, 266600384, 266731072, +266862272, 266993344, 267124288, 267255616, 267386432, 267516992, +267648704, 267777728, 267910592, 268040512, 268172096, 268302784, +268435264, 268566208, 268696256, 268828096, 268959296, 269090368, +269221312, 269352256, 269482688, 269614784, 269745856, 269876416, +270007616, 270139328, 270270272, 270401216, 270531904, 270663616, +270791744, 270924736, 271056832, 271186112, 271317184, 271449536, +271580992, 271711936, 271843136, 271973056, 272105408, 272236352, +272367296, 272498368, 272629568, 272759488, 272891456, 273022784, +273153856, 273284672, 273415616, 273547072, 273677632, 273808448, +273937088, 274071488, 274200896, 274332992, 274463296, 274595392, +274726208, 274857536, 274988992, 275118656, 275250496, 275382208, +275513024, 275643968, 275775296, 275906368, 276037184, 276167872, +276297664, 276429376, 276560576, 276692672, 276822976, 276955072, +277085632, 277216832, 277347008, 277478848, 277609664, 277740992, +277868608, 278002624, 278134336, 278265536, 278395328, 278526784, +278657728, 278789824, 278921152, 279052096, 279182912, 279313088, +279443776, 279576256, 279706048, 279838528, 279969728, 280099648, +280230976, 280361408, 280493632, 280622528, 280755392, 280887104, +281018176, 281147968, 281278912, 281411392, 281542592, 281673152, +281803712, 281935552, 282066496, 282197312, 282329024, 282458816, +282590272, 282720832, 282853184, 282983744, 283115072, 283246144, +283377344, 283508416, 283639744, 283770304, 283901504, 284032576, +284163136, 284294848, 284426176, 284556992, 284687296, 284819264, +284950208, 285081536] +``` diff --git a/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md new file mode 100644 index 00000000000..f251fa3ce68 --- /dev/null +++ b/src/content/translations/fr/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md @@ -0,0 +1,37 @@ +--- +title: Algorithmes de minage +description: Un regard détaillé sur les algorithmes utilisés pour le minage Ethereum. +lang: fr +--- + + +La preuve de travail n'est plus le mécanisme de consensus d'Ethereum, ce qui signifie que le minage a été arrêté. En lieu et place, Ethereum est sécurisé par les validateurs qui misent de l'ETH. Vous pouvez commencer à miser votre ETH dès aujourd'hui. En savoir plus sur La Fusion, la preuve d'enjeu et la mise en jeu. Cette page n'a qu'un intérêt historique. + + +Le minage Ethereum utilisait un algorithme connu sous le nom d'Ethash. L'idée fondamentale de l'algorithme est qu'un mineur tente de trouver une entrée nonce en utilisant le calcul de force brute afin que le hachage en résultant soit plus petit qu'un seuil déterminé par la difficulté calculée. Ce seuil de difficulté peut être ajusté dynamiquement, ce qui permet à la production de blocs de se réaliser à intervalles réguliers. + +## Prérequis {#prerequisites} + +Pour mieux comprendre cette page, nous vous recommandons de lire d'abord le [consensus de preuve de travail](/developers/docs/consensus-mechanisms/pow) et le [minage](/developers/docs/consensus-mechanisms/pow/mining). + +## Dagger Hashimoto {#dagger-hashimoto} + +Dagger Hashimoto était un algorithme de recherche précurseur pour le minage Ethereum qu'Ethash a remplacé. Il s'agissait de la fusion de deux algorithmes différents : Dagger et Hashimoto. Il ne s'agissait que d'une implémentation de recherche et a été remplacé par Ethash au moment du lancement du réseau principal Ethereum. + +[Dagger](http://www.hashcash.org/papers/dagger.html) implique la génération d'un [Graphe orienté acyclique (DAG en anglais)](https://en.wikipedia.org/wiki/Directed_acyclic_graph), dont des tranches aléatoires sont hachées ensemble. Le principe fondamental est que chaque nonce ne nécessite qu'une petite partie d'un grand arbre de données. Recalculer le sous-arbre pour chaque nonce est prohibitif pour le minage – d’où la nécessité de stocker l’arbre – mais correct pour un unique once de vérification. Dagger a été conçu pour être une alternative aux algorithmes existants comme Scrypt, qui sont difficiles à vérifier lorsque la difficulté de mémoire augmente à des niveaux réellement sécurisés. Cependant, Dagger était vulnérable à une accélération matérielle de la mémoire partagée et a été abandonné en faveur d'autres pistes de recherche. + +[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) est un algorithme qui ajoute une résistance ASIC en étant lié aux E / S (c'est-à-dire que les lectures de mémoire sont le facteur limitant du processus de minage). La théorie est que la RAM est plus disponible que le calcul. Des milliards de dollars de recherche ont déjà investis pour étudier les possibilités d'optimisation de la mémoire vive pour différents cas d’utilisation, ce qui implique souvent des modèles d’accès quasi aléatoires (d’où la « mémoire à accès aléatoire »). En conséquence, la RAM existante est susceptible d'être modérément proche de l'optimisation pour l'évaluation de l'algorithme. Hashimoto utilise la blockchain comme source de données, satisfaisant simultanément (1) et (3) ci-dessus. + +Dagger-Hashimoto a utilisé des versions modifiées des algorithmes Dagger et Hashimoto. La différence entre Dagger Hashimoto et Hashimoto réside dans le fait qu'au lieu d'utiliser la blockchain comme une source de données, Dagger Hashimoto utilise un ensemble de données générées sur mesure, qui se met à jour en fonction des données de chaque bloc N. L'ensemble de données est généré à l'aide de l'algorithme Dagger permettant de calculer efficacement un sous-ensemble spécifique à chaque nonce pour l'algorithme de vérification du client léger. La différence entre Dagger Hashimoto et Dagger est que, contrairement à l'original Dagger, le jeu de données utilisé pour interroger le bloc est semi-permanent, mis à jour uniquement à intervalles occasionnels (par exemple une fois par semaine). Cela signifie que la partie de l'effort de génération du jeu de données est proche de zéro. Les arguments de Sergio Lerner concernant les vitesses de mémoires partagées deviennent donc négligeables. + +En savoir plus sur [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto). + +## Ethash {#ethash} + +Ethash était l'algorithme de minage qui était en fait utilisé sur le véritable réseau principal Ethereum sous l'architecture désormais obsolète de la preuve de travail. Ethash a été en fait un nouveau nom donné à une version spécifique de Dagger-Hashimoto après que l'algorithme a été mis à jour de manière significative, tout en héritant des principes fondamentaux de son prédécesseur. Le réseau principal Ethereum a toujours utilisé Ethash - Dagger Hashimoto était une version R&D de l'algorithme de minage qui a été remplacé avant que le minage ne démarre sur le réseau principal Ethereum. + +[En savoir plus sur Ethash](/developers/docs/consensus-mechanisms/pow/mining-algorithms/ethash). + +## Complément d'information {#further-reading} + +_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ diff --git a/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md b/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md index 95ab2385c51..73c4ac397a4 100644 --- a/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md +++ b/src/content/translations/fr/developers/docs/data-and-analytics/block-explorers/index.md @@ -1,5 +1,5 @@ --- -title: Explorateurs de bloc +title: Explorateurs de blocs description: Introduction aux explorateurs de blocs, votre portail vers le monde des données de la blockchain, où vous pouvez rechercher des informations sur les transactions, les comptes, les contrats et bien plus. lang: fr sidebarDepth: 3 @@ -13,66 +13,57 @@ Pour que les données fournies par un explorateur de blocs aient du sens, vous d ## Services {#services} -- [Etherscan](https://etherscan.io/) - _Également disponible en chinois, en coréen, en japonais et en russe_ -- [Etherchain](https://www.etherchain.org/) -- [Ethplorer](https://ethplorer.io/) - _Également disponible en chinois, en espagnol, en français, en turc, en russe, en coréen et en vietnamien_ -- [Blockchair](https://blockchair.com/ethereum) - _Également disponible en chinois, en espagnol, en farsi, en français, en italien, en néerlandais, en portugais et en russe_- +- [Etherscan](https://etherscan.io/) - _Également disponible en chinois, coréen, russe et japonais_ +- [Beaconcha.in](https://beaconcha.in/) +- [Blockchair](https://blockchair.com/ethereum) - _Également disponible en espagnol, français, italien, néerlandais, portugais, russe, chinois et Farsi_ - [Blockscout](https://blockscout.com/) +- [Etherchain](https://www.etherchain.org/) +- [Ethplorer](https://ethplorer.io/) - _Aussi disponible en chinois, espagnol, français, turc, russe, coréen et vietnamien_ - [OKLink](https://www.oklink.com/eth) +- [Otterscan](https://otterscan.io/) +- [Sirato](https://www.web3labs.com/sirato) +- [EthVM](https://www.ethvm.com/) ## Données {#data} -De part sa conception, Ethereum est transparent, tout est donc vérifiable. Les explorateurs de blocs fournissent l'interface pour obtenir les informations, à la fois pour le réseau principal Ethereum (mainnet) et pour les réseaux de test (testnets), si besoin est. +De part sa conception, Ethereum est transparent, tout est donc vérifiable. Les explorateurs de blocs fournissent l'interface pour obtenir les informations, à la fois pour le réseau principal Ethereum (mainnet) et pour les réseaux de test (testnets), si besoin est. Les données sont divisées en données d'exécution et de consensus. Les données d'exécution se réfèrent aux transactions qui ont été exécutées dans un bloc spécifique. Les données de consensus se réfèrent aux blocs eux-mêmes et aux validateurs qui les ont proposés. Voici un résumé des types de données que vous pouvez obtenir d'un explorateur de blocs. -### Blocs {#blocks} +### Données d'exécution {#execution-data} -De nouveaux blocs sont ajoutés à Ethereum environ toutes les 12 secondes (cela peut fluctuer). Un flux de données presque constant est donc ajouté aux explorateurs de blocs. Les blocs contiennent de nombreuses données importantes qui peuvent vous être utiles : +De nouveaux blocs sont ajoutés à Ethereum toutes les 12 secondes (à moins qu'un explorateur de bloc ne manque son tour), afin qu'un flux de données quasi constant soit ajouté aux explorateurs de blocs. Les blocs contiennent de nombreuses données importantes qui peuvent vous être utiles : **Données standards** -- Hauteur du bloc : le numéro de bloc et la longueur de la blockchain (en blocs) lors de la création du bloc actuel. -- Horodatage : date et heure auxquelles un mineur a miné le bloc. -- Transactions : le nombre de transactions incluses dans le bloc. -- Mineur : l'adresse du mineur qui a miné le bloc. -- Récompense : le montant d'ETH attribué au mineur pour avoir ajouté le bloc (récompense standard de 2 ETH + frais de transaction des transactions incluses dans le bloc). -- Difficulté : la difficulté associée au minage du bloc. -- Taille : la taille des données du bloc (mesurée en octets). -- Gaz utilisé : nombre d'unités de gaz utilisées par les transactions du bloc. -- Limite de gaz : le total des limites de gaz fixées par les transactions du bloc. -- Données supplémentaires : toutes les données supplémentaires que le mineur a incluses dans le bloc. +- Block height (hauteur du bloc) - Le numéro de bloc et la longueur de la blockchain (en blocs) lors de la création du bloc actuel +- Timestamp (horodatage) - Le moment où un bloc a été proposé +- Transactions - Le nombre de transactions incluses dans le bloc +- Fee recipient (destinataire de frais) - L'adresse qui a reçu des conseils sur les frais de gaz lors des transactions +- Block Reward (récompense de bloc) - Le montant d'ETH attribué au validateur qui a proposé le bloc +- Size (taille) - La taille des données dans le bloc (mesurée en octets) +- Gas used (gaz utilisé) - L'unité de gaz totale utilisée par les transactions dans le bloc +- Gas limit (limite de gaz) - Les limites totales de gaz fixées par les transactions dans le bloc +- Base fee per gas (frais de base par gaz) - Le multiplicateur minimum requis pour qu'une transaction soit incluse dans un bloc +- Burnt fees (frais brûlés) - Combien d'ETH est brûlé dans le bloc +- Extra data (données supplémentaires) - Toutes les données supplémentaires que le mineur a incluses dans le bloc **Données avancées** -- Hash : le hachage cryptographique qui représente l'en-tête du bloc (l'identifiant unique du bloc). -- Hash parent : le hachage de bloc obtenu avant le bloc actuel. -- Sha3Oncles : le hachage combiné de tous les oncles pour un parent donné. -- StateRoot : la racine de l'arbre de Merkle qui contient l'état complet du système. -- Nonce : une valeur utilisée pour démontrer la preuve de travail du mineur pour un bloc. - -**Blocs oncles** - -Des blocs oncles sont créés lorsque deux mineurs créent des blocs presque en même temps (un seul bloc pouvant être validé par les nœuds). Ils ne sont pas inclus mais génèrent quand même une récompense pour le travail. - -Les explorateurs de blocs fournissent les informations suivantes sur les blocs oncles : - -- Numéro du bloc oncle -- Date et heure de leur création -- Hauteur de bloc à laquelle ils ont été créés -- Nom du mineur -- Récompense en ETH +- Hash (hash) - Le hachage cryptographique qui représente l'en-tête du bloc (l'identifiant unique du bloc) +- Parent hash (hash parent) - Le hachage du bloc qui est arrivé avant le bloc actuel +- StateRoot - Le hash racine de Merkle trie qui stocke l'état complet du système ### Gaz {#gas} -Non seulement les explorateurs de blocs fournissent des données relatives aux blocs et à l'utilisation du gaz dans les transactions, mais certains vous donneront aussi des informations sur les prix actuels du gaz sur le réseau. Cela vous aidera à comprendre l'utilisation du réseau, à soumettre des transactions sûres et à ne pas trop dépenser en gaz. Recherchez les API qui peuvent vous aider à obtenir ces informations dans l'interface de votre produit. Les données concernant le gaz comprennent : +Non seulement les explorateurs de blocs fournissent des données relatives à l'utilisation du gaz dans les transactions et dans les blocs, mais certains vous donneront aussi des informations sur les prix actuels du gaz sur le réseau. Cela vous aidera à comprendre l'utilisation du réseau, à soumettre des transactions sûres et à ne pas trop dépenser en gaz. Recherchez les API qui peuvent vous aider à obtenir ces informations dans l'interface de votre produit. Les données concernant le gaz comprennent : -- une estimation du gaz nécessaire pour une transaction sécurisée, mais lente (+ une estimation du prix et de la durée de la transaction) ; -- une estimation du gaz nécessaire pour une transaction moyenne (+ une estimation du prix et de la durée de la transaction) ; -- une estimation du gaz nécessaire pour une transaction rapide (+ une estimation du prix et de la durée de la transaction) ; -- un délai moyen de confirmation basé sur le prix du gaz ; -- les contrats qui consomment du gaz (en d'autres termes, les produits populaires qui ont une forte utilisation sur le réseau) ; -- les comptes qui consomment du gaz (en d'autres termes, les utilisateurs fréquents du réseau). +- Unités de gaz estimées nécessaires pour une transaction sûre mais lente (+ prix estimé et durée) +- Unités de gaz estimées nécessaires pour une transaction moyenne (+ prix estimé et durée) +- Unités de gaz estimées nécessaires pour une transaction rapide (+ prix estimé et durée) +- Temps de confirmation moyen basé sur le prix du gaz +- Contrats qui consomment du gaz - en d'autres termes, des produits populaires qui voient beaucoup d'utilisation sur le réseau +- Comptes qui dépensent du gaz - en d'autres termes, des utilisateurs fréquents du réseau ### Transactions {#transactions} @@ -80,195 +71,176 @@ De plus en plus d'utilisateurs tirent parti des explorateurs de blocs pour suivr **Données standards** -- Hash de la transaction - Hash généré lorsque la transaction est soumise. -- Statut - Indique si la transaction est en cours, a échoué ou a réussi. -- Bloc - Bloc dans lequel la transaction a été incluse. -- Horodatage - Moment auquel un mineur a miné la transaction. -- De - Adresse du compte qui a soumis la transaction. -- À - Adresse du destinataire ou du contrat intelligent avec lequel la transaction interagit. -- Jetons transférés - Liste des jetons transférés dans le cadre de la transaction. -- Valeur - Valeur totale en ETH de ce qui a été transféré. -- Frais de transaction - Montant payé aux mineurs pour traiter la transaction (prix du gaz x gaz utilisé). +- Transaction hash (hachage de la transaction) - Un hachage généré lorsque la transaction est soumise +- Status (statut) - Une indication si la transaction est en attente, a échoué ou a réussi +- Block (bloc) - Le bloc dans lequel la transaction a été incluse +- Timestamp (horodatage) - Le moment où un mineur a extrait la transaction +- From (de) - L'adresse du compte qui a soumis la transaction +- To (à) - L'adresse du destinataire ou du contrat intelligent avec lequel la transaction interagit +- Tokens transferred (jetons transférés) - Une liste de jetons qui ont été transférés dans le cadre de la transaction +- Value (valeur) - La valeur ETH totale en cours de transfert +- Transaction fee (frais de transaction) - Le montant payé au mineur pour traiter la transaction (calculé par le prix du gaz\*gaz utilisé) **Données avancées** -- Limite de gaz - Nombre maximum d'unités de gaz que la transaction peut consommer. -- Gaz consommé - Montant de gaz réellement consommé par la transaction. -- Prix du gaz - Prix fixé par unité de gaz. -- Nonce - Numéro de transaction de l'adresse `expéditeur` (rappelez-vous que cela commence à 0, donc une once de `100` équivaut en fait à la 101ième transaction soumise par ce compte). -- Données de saisie - Toute information supplémentaire requise par la transaction. +- Gas limit (limite de gaz) - Le nombre maximum d'unités de gaz que cette transaction peut consommer +- Gas used (gaz utilisé) - Le montant réel des unités de gaz consommées par la transaction +- Gas price (prix du gaz) - Le prix fixé par unité de gaz +- Nonce - Le numéro de transaction pour l'adresse `from` (gardez à l'esprit que cela commence à 0 donc un nonce de `100` serait en fait la 101e transaction soumise par ce compte +- Input data (données d'entrée) - Toutes les informations supplémentaires requises par la transaction ### Comptes {#accounts} -Il est possible d'accéder à de nombreuses données concernant un compte. C'est pourquoi il est souvent conseillé d'utiliser plusieurs comptes afin qu'il soit difficile de traquer vos capitaux et leur valeur. Plusieurs solutions sont aussi développées dans le but de rendre les transactions et l'activité d'un compte plus privée. Les données disponibles sur les comptes sont les suivantes : +Il est possible d'accéder à de nombreuses données concernant un compte. C'est pourquoi il est souvent conseillé d'utiliser plusieurs comptes afin qu'il soit difficile de traquer vos capitaux et leur valeur. Plusieurs solutions sont aussi développées dans le but de rendre les transactions et l'activité d'un compte plus privée. Mais les données disponibles sur les comptes sont les suivantes : **Comptes utilisateur** -- Adresse du compte - Adresse publique que vous pouvez utiliser pour envoyer des fonds. -- Solde ETH - Montant des ETH associés à ce compte. -- Valeur totale des ETH - Valeur des ETH. -- Jetons - Jetons associés au compte et leur valeur. -- Historique des transactions - Liste de toutes les transactions pour lesquelles le compte était soit l'expéditeur soit le destinataire. +- Account address (adresse du compte) - L'adresse publique que vous pouvez utiliser pour envoyer des fonds à +- ETH balance (solde ETH) - Le montant d'ETH associé à ce compte +- Valeur ETH totale (valeur ETH totale) - La valeur de l'ETH +- Tokens (jetons) - Les jetons associés au compte et à leur valeur +- Transaction history (historique des transactions) - Une liste de toutes les transactions où ce compte était soit l'expéditeur soit le destinataire **Contrats intelligents** Les comptes de contrats intelligents possèdent toutes les données d'un compte utilisateur, mais certains explorateurs de bloc afficheront aussi certaines informations liées au code. Par exemple : -- Créateur du contrat - Adresse qui a déployé le contrat sur le réseau principal. -- Transaction de création - Transaction qui inclut le déployement sur le réseau principal. -- Code source - Code Solidity ou Vyper du contrat intelligent. -- ABI du contrat - L'interface binaire d'application du contrat (les appels effectués par le contrat et les données reçues). -- Code de création du contrat - Bytecode compilé du contrat intelligent, créé lorsque vous compilez un contrat intelligent écrit en Solidity, Vyper, etc. -- Événements du contrat - Historique des méthodes appelées dans le contrat intelligent. Il s'agit essentiellement d'un moyen de voir comment le contrat est utilisé et à quelle fréquence. +- Contract creator (créateur de contrat) - L'adresse qui a déployé le contrat sur le réseau principal +- Creation transaction (transaction de création) - La transaction qui inclut le déploiement sur le réseau principal +- Source code (code source) - La solidité ou le code vyper du contrat intelligent +- Contract ABI (contrat IBA) - L'Interface Binaire d'Application du contrat - les appels effectués par le contrat et les données reçues +- Contract creation code (code de création de contrat) - Le bytecode compilé du contrat intelligent, créé lorsque vous compilez un contrat intelligent écrit en Solidity ou Vyper, etc. +- Contract events (événements du contrat) - Une histoire des méthodes appelées dans le contrat intelligent, essentiellement un moyen de voir comment le contrat est utilisé et combien de fois ### Jetons {#tokens} -Les jetons sont un type de contrat et comporteront donc des données similaires à celles d'un contrat intelligent. Mais comme ils ont une valeur et peuvent être échangés, ils comportent des données supplémentaires : +Les jetons sont un type de contrat, donc ils auront des données similaires à un contrat intelligent. Mais comme ils ont une valeur et peuvent être échangés, ils comportent des données supplémentaires : -- Type - Jeton ERC-20, ERC-721 ou une autre norme de jeton. -- Prix - S'il s'agit de jetons ERC-20, ils auront une valeur sur le marché actuel. -- Valorisation au prix du marché - S'il s'agit de jetons ERC-20, ils feront l'objet d'une valorisation au prix du marché (prix d'un jeton x nombre total de jetons en circulation). -- Offre totale - Le nombre total de jetons en circulation. -- Détenteurs - Nombre d'adresses détenant le jeton. -- Transferts : Nombre de transferts d'un jeton entre des comptes. -- Historique des transactions - Historique de toutes les transactions effectuées incluant le jeton. -- Adresse du contrat - Adresse du jeton qui a été déployé sur le réseau principal. -- Décimales - Les jetons ERC-20 sont divisibles et ont des décimales. +- Type - Qu'il s'agisse d'un ERC-20, d'un ERC-721 ou d'un autre standard de jeton +- Price (prix) - S'il s'agit d'un ERC-20, il aura une valeur de marché actuelle +- Market cap (capitalisation boursière) - S'il s'agit d'un ERC-20, il aura une limite de marché (calculée par le prix\*fourniture totale) +- Total supply (fourniture totale) - Le nombre de jetons en circulation +- Holders (titulaires) - Le nombre d'adresses qui contiennent le jeton +- Transfers (transferts) - Le nombre de fois où le jeton a été transféré entre les comptes +- Transaction history (historique des transactions) - Un historique de toutes les transactions y compris le jeton +- Contract address (adresse du contrat) - L'adresse du jeton qui a été déployé sur le réseau principal +- Decimals (décimales) - Les jetons ERC-20 sont divisibles et ont des décimales ### Réseau {#network} -Bien sûr, certaines données parlent de la santé du réseau. Elle sont très spécifiques au mécanisme Ethereum de consensus par preuve de travail . Quand Ethereum effectuera la transition la Preuve d'enjeu certaines de ces données seront redondantes. +Certaines données de bloc sont préoccupées par la santé d'Ethereum de manière plus globale. -- Difficulté - Difficulté actuelle du minage. -- Taux de hachage - Estimation du nombre de hachages générés par les mineurs Ethereum qui essayent de résoudre le bloc Ethereum actuel ou n'importe quel bloc donné. -- Total des transactions - Nombre de transactions depuis qu'Ethereum existe. -- Transactions par seconde - Nombre de transactions pouvant être traitées en une seconde. -- Prix de l'ETH - Valeur actuelle d'un ETH. -- Offre totale d'ETH - Nombre d'ETH en circulation. Rappelez-vous que des ETH sont créés avec chaque nouveau bloc sous la forme de récompenses. -- Valorisation au prix du marché - Prix d'un ETH x l'offre totale. +- Total transactions (total des transactions) - Le nombre de transactions depuis la création d'Ethereum +- Transactions per second (transactions par seconde) - Le nombre de transactions pouvant être traitées en une seconde +- ETH price (prix de l'ETH) - Les évaluations actuelles de 1 ETH +- Total ETH supply (fourniture totale d'ETH) - Nombre d'ETH en circulation - souvenez-vous que de nouveaux ETH sont créés avec la création de chaque bloc sous la forme de récompenses de blocs +- Market cap (capitalisation boursière) - Calcul du prix\*approvisionnement ## Données de couche de consensus {#consensus-layer-data} -Les mises à niveau d'évolutivité sont toujours en cours de développement, mais il est intéressant de parler des points de données que les explorateurs seront capables de vous fournir. En fait, toutes ces données sont déjà disponibles pour les réseaux de test. - -Si vous n'êtes pas familiarisé avec la feuille de route, consultez [notre vue d'ensemble des mises à jour Ethereum](/roadmap/). - ### Période {#epoch} -La chaîne phare va créer aléatoirement des comités de validateurs à la fin de chaque période (toutes les 6,4 minutes) pour des raisons de sécurité. Les données de la période incluent les éléments suivants : +Pour des raisons de sécurité, des comités aléatoires de validateurs sont créés à la fin de chaque epoch (toutes les 6,4 minutes). Les données de l'epoch incluent les éléments suivants : -- Numéro de la période. -- Statut de finalisation - Si la période a été finalisée (Oui/Non). -- Temps - Moment auquel la période s'est terminée. -- Attestations - Nombre d'attestations pendant la période (les votes pour les blocs au sein des créneaux). -- Dépôts - Nombre d'ETH déposés dans la période (les utilisateurs doivent miser des ETH pour devenir validateurs). -- Délestages - Nombre de pénalités infligées à ceux qui proposent ou valident les blocs. -- Participation aux votes - Montant des ETH misés pour valider les blocs. -- Validateurs - Nombre de validateurs actifs pour la période. -- Solde moyen des validateurs - Solde moyen des validateurs actifs. -- Créneaux - Nombre de créneaux inclus dans la période (les créneaux incluent un bloc valide). +- Numéro d'epoch +- Finalized status (statut finalisé) - Si l'epoch a été finalisée (Oui/Non) +- Time (temps) - La date de la fin de l'epoch +- Attestations - Le nombre d'attestations dans l'epoch (votes pour les blocs à l'intérieur des créneaux) +- Deposits (dépôts) - Le nombre de dépôts ETH inclus à l'epoch (les validateurs doivent miser des ETH pour devenir valideurs) +- Slashings (taillades) - Nombre de pénalités accordées aux promoteurs de blocs ou d'attestations +- Voting participation (participation au vote) - Le montant d'ETH misé utilisé pour attester les blocs +- Validators (validateurs) - Nombre de validateurs actifs pour l'epoch +- Average Validator balance (solde Moyen du Validateur) - Solde moyen pour les validateurs actifs +- Slots (créneaux) - Nombre de créneaux inclus dans l'epoch (les créneaux incluent un bloc valide) ### Créneau {#slot} Les créneaux sont des opportunités de création de blocs. Les données disponibles pour chaque créneau comprennent les éléments suivants : -- Période - Période pendant laquelle le créneau est valide. -- Numéro de créneau. -- Statut - Statut de le créneau (Proposé/Manqué). -- Temps - Horodatage de le créneau. -- Proposant - Validateur qui a proposé le bloc pour le créneau. -- Block root - Le hash-tree-root de BeaconBlock. -- Racine parente - Le hachage du bloc précédent. -- Racine d'état - Le hash-tree-root de BeaconState. -- Signature. -- Randao reveal. -- Graffiti - Quiconque soumet un bloc peut intégrer un message de 32 octets à sa proposition de bloc. -- Données d'exécution. - - Hash du bloc. - - Nombre de dépôts. - - Dépôt racine. -- Attestations - Nombre d'attestations pour le bloc dans cet créneau. -- Dépôts - Nombre de dépôts dans cet créneau. -- Sorties volontaires - Nombre de validateurs qui sont partis pendant ce créneau. -- Délestages - Nombre de pénalités infligées à ceux qui proposent ou valident les blocs. -- Votes - Les validateurs qui ont voté pour le bloc pendant ce créneau. +- Epoch (époque) - L'époque dans laquelle le créneau est valide +- Numéro de créneau +- Status (statut) - Le statut du créneau (Proposé/Manqué) +- Time (temps) - L'horodatage du créneau +- Proposer (proposant) - Le validateur qui a proposé le bloc pour le créneau +- Block root (racine du bloc) - La racine du hash-tree du BeaconBlock +- Parent root (racine parente) - Le hachage du bloc qui vient avant +- State root (racine d'état) - La racine de hash-tree du BeaconState +- Signature +- Randao reveal +- Graffiti - Un bloc proposant peut inclure un message de 32 octets à sa proposition de bloc +- Données d'exécution + - Hash du bloc + - Nombre de dépôts + - Dépôt racine +- Attestations - Nombre d'attestations pour le bloc dans ce créneau +- Deposits (dépôts) - Le nombre de dépôts pendant ce créneau +- Voluntary exits (sortie volontaire) - Le nombre de validateurs qui sont restés pendant le créneau +- Slashings (taillades) - Nombre de pénalités accordées aux promoteurs de blocs ou d'attestations +- Votes - Les validateurs qui ont voté pour le bloc de ce créneau ### Blocs {#blocks-1} -Les blocs de couches de consensus fonctionnent différemment car les mineurs sont remplacés par les validateurs, et la chaîne phare introduit les créneaux et les périodes dans Ethereum. Cela engendre donc de nouvelles données ! +Le Proof-of-stake (la preuve de mise en jeu) divise le temps en créneaux et époques. Cela engendre donc de nouvelles données ! -- Proposant - Validateur que l'algorithme a choisi pour proposer le nouveau bloc. -- Période - Période pendant laquelle le bloc a été proposé. -- Créneau - Le créneau dans lequel le bloc a été proposé. -- Attestations - Nombre d'attestation incluses dans le créneau. Les attestations sont comme des votes qui indiquent que le bloc est prêt à être intégré à la chaîne phare. +- Proposer (proposant) - Le validateur qui a été choisi par algorithme pour proposer le nouveau bloc +- Epoch (époque) - L'époque où le bloc a été proposé +- Slot (emplacement) - L'emplacement dans lequel le bloc a été proposé +- Attestations - Le nombre d'attestations incluses dans le créneau — les attestations sont comme des votes qui indiquent que le bloc est prêt à aller à la Beacon Chain (Chaîne phare) ### Validateurs {#validators} Les validateurs doivent proposer des blocs et attester de leur conformité dans les créneaux. -- Numéro de validateur - Numéro unique qui représente le validateur. -- Solde actuel - Solde du validateur qui inclut les récompenses. -- Solde effectif - Solde du validateur utilisé pour miser. -- Revenus - Récompenses ou pénalités reçues par le validateur. -- Statut - Détermine si le validateur est en ligne et actif ou non. -- Attestation d'efficacité - Délai moyen nécessaire pour que les attestations du validateurs soient incluses dans la chaîne. -- Admissibilité à l'activation - Date (et période) à laquelle le validateur est devenu disponible pour valider. -- Actif depuis - Date (et période) à laquelle le validateur est devenu actif. -- Blocs proposés - Blocs proposés par le validateur. -- Attestations - Attestations fournies par le validateur. -- Dépôts - Adresse de l'expéditeur, hash de la transaction, numéro de bloc, horodatage, montant et statut de la mise effectuée par le validateur. +- Validator number (numéro de validateur) - Nombre unique qui représente le validateur +- Current balance (solde actuel) - Le solde du validateur y compris les récompenses +- Effective balance (solde effectif) - Le solde du validateur qui est utilisé pour le staking +- Income (revenu) - Récompenses ou pénalités reçues par le validateur +- Status (statut) - Si le validateur est actuellement en ligne et actif ou non +- Attestation effectiveness (efficacité de l'attestation) - Le temps moyen nécessaire pour inclure les attestations du validateur dans la chaîne +- Eligibility for activation (admissibilité à l'activation) - Date (et epoch) quand le validateur est devenu disponible pour valider +- Active since (actif depuis) - Date (et epoch) quand le validateur est devenu actif +- Proposed blocks (blocs proposés) - Le bloc que le validateur a proposé +- Attestations - Les attestations que le validateur a fournies +- Deposits (dépôts) - L'adresse, le hachage de la transaction, le numéro de bloc, l'horodatage, le montant et le statut du dépôt de staking effectué par le validateur ### Attestations {#attestations} Les attestations sont des votes positifs pour inclure les blocs dans la chaîne. Leurs données portent sur leur enregistrement et les validateurs qui les ont émises. -- Créneau - Créneau dans lequel l'attestation a eu lieu. -- Index du comité - Index du comité à un créneau donné. -- Bits d’agrégation – Représente l’attestation regroupant tous les validateurs ayant participé à l’attestation. -- Validateurs - Validateurs qui ont fournis les attestations. -- Racine du bloc phare - Pointe vers le bloc sur lequel les validateurs apposent leur attestation. -- Source - Pointe vers la dernière période validée. -- Cible - Indique la limite de période la plus récente. -- Signature. +- Slot (créneau) - Le créneau dans lequel l'attestation a eu lieu +- Committee index (indice du comité) - L'indice du comité au créneau donné +- Aggregation bits (bits d'agrégation) - Représente l'attestation agrégée de tous les validateurs participants dans l'attestation +- Validators (validateurs) - Les validateurs qui ont fourni des attestations +- Beacon block root (racine du bloc de balises) - Points vers le bloc auquel les validateurs sont en train d'attester +- Source - Points de la dernière epoch justifiée +- Target (cible) - Points à la dernière frontière de l'epoch +- Signature ### Réseau {#network-1} Les données de couches de consensus de haut niveau comprennent les éléments suivants : -- Période actuelle. -- Créneau actuel. -- Validateurs actifs - Nombre de validateurs actifs. -- Validateurs en attente - Nombre de validateurs attendant d'être activés. -- ETH misés - Montant des ETH misés sur le réseau. -- Solde moyen - Solde moyen d'ETH des validateurs. +- epoch actuelle +- Créneau actuel +- Active validators (validateurs actifs) - Nombre de validateurs actifs +- Pending validators (validateurs en attente) - Nombre de validateurs en attente d'être rendus actifs +- Staked ETH (ETH absorbé) - Quantité d'ETH misé dans le réseau +- Average balance (solde moyen) - Solde moyen ETH des validateurs ## Explorateurs de bloc {#block-explorers} -- [Etherscan](https://etherscan.io/) - Explorateur de blocs que vous pouvez utiliser pour récupérer des données sur le réseau principal Ethereum ainsi que sur les réseaux de test Ropsten, Kovan, Rinkeby et Goerli. -- [Blockscout](https://blockscout.com/) - Axé sur les réseaux suivants : - - xDai - Combinaison intelligente du stablecoin DAI de MakerDao avec la chaîne latérale et la technologie tokenbridge de POA. - - POA - Chaîne latérale et réseau autonome sécurisés par un groupe de validateurs de confiance. Tous les validateurs du réseau sont des notaires américains, et leurs informations sont publiquement disponibles. - - Réseau de test POA Sokol. - - ARTIS - Blockchain compatible avec Ethereum. - - [LUKSO L14](https://blockscout.com/lukso/l14) - L14 fonctionne comme premier réseau de test pour permettre à la communauté LUKSO de construire et de tester une infrastructure commune. - - qDai. -- [Etherchain](https://www.etherchain.org/) - Explorateur de blocs pour le réseau principal Ethereum. -- [Ethplorer](https://ethplorer.io/) - Explorateur de blocs qui se focalise sur les jetons du réseau principal Ethereum ainsi que sur le réseau de test Kovan. -- [Blockchair](https://blockchair.com/ethereum) - L'explorateur Ethereum le plus privé. Aussi pour le tri et le filtrage des données (mempool). - -## Les explorateurs de blocs de la chaîne phare (couche de consensus) {#beacon-chain-block-explorers} - -- [https://beaconcha.in/](https://beaconcha.in/) -- [https://beaconscan.com/](https://beaconscan.com/) -- [https://ethscan.org/](https://ethscan.org/) (fourche de beaconcha.in) +- [Etherscan](https://etherscan.io/) - un explorateur de blocs que vous pouvez utiliser pour récupérer des données pour le réseau principal Ethereum et le réseau de test Goerli +- [Beaconcha.in](https://beaconcha.in/) - un explorateur de blocs open source pour le réseau principal Ethereum et le réseau de test Goerli +- [Blockchair](https://blockchair.com/ethereum) - L'explorateur Ethereum le plus privé. Egalement pour trier et filtrer des données (mempool). +- [Etherchain](https://www.etherchain.org/) - un explorateur de blocs pour le réseau principal Ethereum +- [Ethplorer](https://ethplorer.io/) - un explorateur de blocs avec une focalisation sur les jetons pour le réseau principal Ethereum et le réseau de test Kovan -## Complément d'information {#further-reading} +## En savoir plus {#further-reading} _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ ## Sujets connexes {#related-topics} -- [Minage](/developers/docs/consensus-mechanisms/pow/mining/) - [Transactions](/developers/docs/transactions/) - [Comptes](/developers/docs/accounts/) - [Réseaux](/developers/docs/networks/) diff --git a/src/content/translations/fr/developers/docs/data-and-analytics/index.md b/src/content/translations/fr/developers/docs/data-and-analytics/index.md index 7ece500302b..05673f7eeeb 100644 --- a/src/content/translations/fr/developers/docs/data-and-analytics/index.md +++ b/src/content/translations/fr/developers/docs/data-and-analytics/index.md @@ -1,35 +1,45 @@ --- -title: Données et statistiques -description: Comment obtenir des analyses et des données sur la blockchain utiles pour votre Dapps +title: Données et analyses +description: Comment obtenir des analyses et des données en chaîne utiles pour vos dApps lang: fr --- ## Introduction {#Introduction} -À mesure que l'utilisation du réseau continue de croître, une quantité croissante d'informations précieuses existera dans les données sur la blockchain. Au fur et à mesure que le volume des données augmente, le calcul et l'assemblage de ces informations pour faire un compte-rendu ou faire fonctionner une dApp peut devenir long et nécessiter de gros efforts. +À mesure que l'utilisation du réseau continue de croître, une quantité croissante d'informations précieuses existera dans les données en chaîne. Au fur et à mesure que le volume des données augmente, le calcul et l'assemblage de ces informations pour faire un compte rendu ou faire fonctionner une dApp peut devenir long et nécessiter de gros efforts. Les fournisseurs de données existants peuvent accélérer le développement, produire des résultats plus précis et réduire les efforts de maintenance. Cela permettra à une équipe de se concentrer sur la fonctionnalité de base que son projet essaie de fournir. ## Pré-requis {#prerequisites} -Vous devez comprendre le concept de base des [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) afin de mieux comprendre leur utilisation dans le contexte de l'analyse des données. De plus, familiarisez-vous avec le concept d' [index](/glossary/#index) pour comprendre les avantages qu'ils apportent à la conception d'un système. +Vous devez comprendre le concept de base des [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) afin de mieux comprendre leur utilisation dans le contexte de l'analyse des données. De plus, familiarisez-vous avec le concept d'[indice](/glossary/#index) pour comprendre les avantages qu'ils apportent à la conception d'un système. En termes de fondamentaux architecturaux, comprendre ce qu'est une [API](https://www.wikipedia.org/wiki/API) et un[REST](https://www.wikipedia.org/wiki/Representational_state_transfer) (Representational state transfer), même en théorie. +## Explorateurs de bloc {#block-explorers} + +De nombreux [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) offrent des passerelles [RESTful](https://www.wikipedia.org/wiki/Representational_state_transfer) [API](https://www.wikipedia.org/wiki/API) qui fournissent une visibilité aux développeurs sur les données en temps réel sur les blocs, les transactions, les mineurs, les comptes et autres activités sur la blockchain. + +Les développeurs peuvent alors traiter et transformer ces données afin de leur donner leurs informations d'utilisateurs uniques et leurs interactions avec la [blockchain](/glossary/#blockchain). Par exemple, [Etherscan](https://etherscan.io) fournit des données d'exécution et de consensus pour chaque créneau de 12 secondes. + ## Le réseau Graph {#the-graph} -Le [réseau Graph](https://thegraph.com/) est un protocole d'indexation décentralisé pour organiser les données de la blockchain. Au lieu de construire et de gérer des stockages de données hors chaîne et centralisés pour agréger les données sur la blockchain, avec The Graph, les développeurs peuvent construire des applications sans serveur qui fonctionnent entièrement sur une infrastructure publique. +Le [réseau Graph](https://thegraph.com/) est un protocole d'indexation décentralisé pour organiser les données de la blockchain. Au lieu de construire et de gérer des stockages de données hors chaîne et centralisés pour agréger les données sur la chaîne, avec The Graph, les développeurs peuvent construire des applications sans serveur qui fonctionnent entièrement sur une infrastructure publique. -En utilisant [GraphQL](https://graphql.org/), les développeurs peuvent interroger n'importe laquelle des API ouvertes organisées, connues sous le nom de sub-graphs, pour acquérir les informations nécessaires pour faire fonctionner leur dApp. En interrogeant ces subs-graphs indexés, les rapports et les dApps non seulement obtiennent des avantages en termes de performances et d'évolutivité, mais obtiennent aussi la précision intégrée fournie par consensus sur le réseau. Au fur et à mesure que de nouvelles améliorations et/ou sub-graphs sont ajoutées au réseau, vos projets peuvent rapidement se renouveler pour tirer parti de ces améliorations. +En utilisant [GraphQL](https://graphql.org/), les développeurs peuvent interroger n'importe laquelle des API ouvertes organisées, connues sous le nom de sub-graphe, pour acquérir les informations nécessaires pour faire fonctionner leur dApp. En interrogeant ces subs-graphs indexés, les rapports et les dApps non seulement obtiennent des avantages en termes de performances et d'évolutivité, mais obtiennent aussi la précision intégrée fournie par consensus sur le réseau. Au fur et à mesure que de nouvelles améliorations et/ou sub-graphs sont ajoutées au réseau, vos projets peuvent rapidement se renouveler pour tirer parti de ces améliorations. -## Explorateurs de bloc {#block-explorers} +## Diversité des clients -De nombreux [Explorateurs de bloc](/developers/docs/data-and-analytics/block-explorers/) offrent des passerelles [RESTful](https://www.wikipedia.org/wiki/Representational_state_transfer) [API](https://www.wikipedia.org/wiki/API) qui fournissent une visibilité aux développeurs sur les données en temps réel sur les blocs, les transactions, les mineurs, les comptes et autres activités sur la blockchain. +[La diversité du client](/developers/docs/nodes-and-clients/client-diversity/) est importante pour la santé globale du réseau Ethereum, car elle fournit de la résilience aux bogues et aux exploitations. Il y a maintenant plusieurs tableaux de bord de diversité de clients dont [clientdiversity.org, [rated.etwork](rated.network), [execution-diversity.info](https://execution-diversity.info/), [](https://ethernodes.org/) et Ethernodes](https://clientdiversity.org/). + +## Dune Analytics {#dune-analytics} -Les développeurs peuvent alors traiter et transformer ces données afin de leur donner leurs informations d'utilisateurs uniques et leurs interactions avec la [blockchain](/glossary/#blockchain). +[Dune Analytics](https://dune.com/) prétraite les données de la blockchain en tables de base de données relationnelles (PostgreSQL et DatabricksSQL), permet aux utilisateurs d'interroger les données de la blockchain en utilisant SQL et de construire des tableaux de bord basés sur les résultats des requêtes. Les données sur la chaîne sont réparties en 4 tables brutes : `blocs`, `transactions`, (événement) `logs` et (appel) `traces`. Les contrats et protocoles populaires ont été décodés et chacun a son propre ensemble de tables d'événements et d'appels. Ces tables d'événements et d'appels sont traitées et organisées en tables d'abstraction par le type de protocoles, par exemple, dex, prêt, stablecoins, etc. ## Complément d'information {#further-reading} - [Présentation du réseau Graph](https://thegraph.com/docs/en/about/network/) - [Bac à sable de requêtes Graph](https://thegraph.com/explorer/subgraph/graphprotocol/graph-network-mainnet?version=current) - [Examples de code d'APIs sur EtherScan](https://etherscan.io/apis#contracts) +- [Explorateur de Beacon Chain](https://beaconcha.in) +- [Basiques de Dune](https://docs.dune.com/#dune-basics) diff --git a/src/content/translations/fr/developers/docs/development-networks/index.md b/src/content/translations/fr/developers/docs/development-networks/index.md index eed821e54e9..99698d1a813 100644 --- a/src/content/translations/fr/developers/docs/development-networks/index.md +++ b/src/content/translations/fr/developers/docs/development-networks/index.md @@ -6,27 +6,27 @@ lang: fr Quand vous construirez une application Ethereum avec des contrats intelligents, vous voudrez l'exécuter sur un réseau local pour vérifier son fonctionnement avant de la déployer. -De la même façon que vous exécuteriez un serveur local sur votre ordinateur pour du développement Web, vous pouvez utiliser un réseau de développement pour créer une occurrence de blockchain locale et tester votre application décentralisée (DApp). Ces réseaux de développement Ethereum fournissent des fonctionnalités permettant une itération beaucoup plus rapide qu'un réseau de test public (par exemple, vous n'avez pas à gérer l'acquisition d'ETH depuis le robinet d'un réseau de test). +De la même façon que vous exécuteriez un serveur local sur votre ordinateur pour du développement Web, vous pouvez utiliser un réseau de développement pour créer une occurrence de blockchain locale et tester votre application décentralisée (dApp). Ces réseaux de développement Ethereum fournissent des fonctionnalités permettant une itération beaucoup plus rapide qu'un réseau de test public (par exemple, vous n'avez pas à gérer l'acquisition d'ETH depuis le robinet d'un réseau de test). ## Prérequis {#prerequisites} Vous devrez comprendre les [bases de la pile Ethereum](/developers/docs/ethereum-stack/) et des [réseaux Ethereum](/developers/docs/networks/) avant de vous plonger dans les réseaux de développement. -## Qu'est-ce qu'un réseau de développement? {#what-is-a-development-network} +## Qu'est-ce qu'un réseau de développement ? {#what-is-a-development-network} Les réseaux de développement sont essentiellement des clients Ethereum (implémentations d'Ethereum) spécifiquement conçus pour le développement local. **Pourquoi ne pas juste exécuter un nœud Ethereum standard localement ?** -Vous _pourriez_ [ exécuter un nœud](/developers/docs/nodes-and-clients/#running-your-own-node) (tels que Geth, Erigon, ou Nethermind) mais puisque les réseaux de développement sont conçus pour le développement, ils sont souvent fournis avec des fonctionnalités pratiques telles que: +Vous _pourriez_ [ exécuter un nœud](/developers/docs/nodes-and-clients/#running-your-own-node) mais puisque les réseaux de développement sont conçus pour le développement, ils sont souvent fournis avec des fonctionnalités pratiques telles que : - Alimentation déterminée de votre blockchain locale avec des données (par exemple, des comptes avec des soldes d'ETH) -- Minage instantané de blocs avec chaque transaction reçue, dans l'ordre et sans délai -- Fonctionnalités de débogage et de consignation améliorées +- Production instantanée de blocs avec chaque transaction reçue, dans l'ordre et sans délai +- Fonctionnalités de débogage et de logging améliorées ## Outils disponibles {#available-projects} -**Remarque** : La plupart des [frameworks de développement](/developers/docs/frameworks/) incluent un réseau de développement intégré. Nous recommandons de démarrer avec un framework pour [configurer votre environnement de développement local](/developers/local-environment/). +**Remarque** : La plupart des [cadres de développement](/developers/docs/frameworks/) incluent un réseau de développement intégré. Nous recommandons de démarrer avec un cadre pour [configurer votre environnement de développement local](/developers/local-environment/). ### Ganache {#ganache} @@ -47,6 +47,21 @@ Le réseau Hardhat est intégré avec Hardhat, un environnement de développemen - [Site Web](https://hardhat.org/) - [GitHub](https://github.com/nomiclabs/hardhat) +### Chaînes phares locales {#local-beacon-chains} + +Certains clients de consensus disposent d'outils intégrés pour faire tourner les chaînes phares locales à des fins de test. Les instructions pour Lighthouse, Nimbus et Lodestar sont disponibles ici : + +- [Réseau de test local utilisant Lodestar](https://chainsafe.github.io/lodestar/usage/local/) +- [Réseau de test local utilisant Lighthouse](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets) +- [Réseau de test local utilisant Nimbus](https://github.com/status-im/nimbus-eth1/blob/master/fluffy/docs/local_testnet.md) + +### Chaînes publiques de test pour Ethereum {#public-beacon-testchains} + +Il y a aussi deux implémentations de test publiques maintenues d'Ethereum : Goerli et Sepolia. Le réseau testnet recommandé avec support à long terme est Goerli, que tout le monde est libre de valider. Sepolia est une nouvelle chaîne plus petite et devrait également être maintenue dans un avenir proche, avec un ensemble de validateurs autorisés (ce qui signifie qu'il n'y a pas d'accès général aux nouveaux validateurs sur ce réseau de test). La chaîne Ropsten devrait être dépréciée au quatrième trimestre 2022, et la chaîne Rinkeby devrait être dépréciée aux T2/T3 2023. + +- [Plateforme de lancement de la mise en jeu de Goerli](https://goerli.launchpad.ethereum.org/) +- [Ropsten, Rinkeby & Annonce de dépréciation Kiln](https://blog.ethereum.org/2022/06/21/testnet-deprecation) + ## Complément d'information {#further-reading} _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ diff --git a/src/content/translations/fr/developers/docs/ethereum-stack/index.md b/src/content/translations/fr/developers/docs/ethereum-stack/index.md index c392cc20a81..20257e110ac 100644 --- a/src/content/translations/fr/developers/docs/ethereum-stack/index.md +++ b/src/content/translations/fr/developers/docs/ethereum-stack/index.md @@ -10,11 +10,11 @@ Il existe cependant des technologies Ethereum de base qui contribuent à fournir ## Niveau 1: Machine virtuelle Ethereum {#ethereum-virtual-machine} -La [machine virtuelle Ethereum (EVM)](/developers/docs/evm/) est l'environnement d'exécution des contrats intelligents Ethereum. Tout contrat intelligent et changement d'état sur la blockchain Ethereum sont exécutés par des [transactions](/developers/docs/transactions/). L'EVM gère l'ensemble du traitement des transactions sur le réseau Ethereum. +La [machine virtuelle Ethereum (EVM)](/developers/docs/evm/) est l'environnement d'exécution des contrats intelligents sur Ethereum. Tout contrat intelligent et changement d'état sur la blockchain Ethereum sont exécutés par des [transactions](/developers/docs/transactions/). L'EVM gère l'ensemble du traitement des transactions sur le réseau Ethereum. Comme toute machine virtuelle, l'EVM crée un niveau d'abstraction entre l'exécution du code et la machine qui l'exécute (un nœud Ethereum). Actuellement, l'EVM s'exécute sur des milliers de nœuds répartis à travers le monde. -De façon non visible, l'EVM utilise un ensemble d'instructions de codes d'opérations (opcodes) pour exécuter des tâches spécifiques. Ces 140 opcodes uniques permettent à l'EVM d'être Turing-complet, ce qui signifie qu'elle est capable de calculer à peu près tout, à partir du moment où elle dispose des ressources suffisantes. +De façon non visible, l'EVM utilise un ensemble d'instructions de codes d'opérations (opcodes) pour exécuter des tâches spécifiques. Ces 140 op codes (uniques) permettent à l'EVM d'être [Turing-complete](https://en.wikipedia.org/wiki/Turing_completeness), ce qui signifie que l'EVM est capable de calculer à peu près n'importe quoi, compte tenu de ressources suffisantes. En tant que développeur de DApp, vous n'avez pas besoin d'en savoir beaucoup plus sur l'EVM, à part qu'elle existe et qu'elle assure de façon fiable le bon fonctionnement des applications sur Ethereum sans temps d'arrêt. @@ -24,7 +24,7 @@ En tant que développeur de DApp, vous n'avez pas besoin d'en savoir beaucoup pl Les contrats intelligents sont rédigés avec des [langages de programmation](/developers/docs/smart-contracts/languages/) spécifiques qui se compilent en bytecode EVM (instructions machine de bas niveau appelées codes d'opérations). -Non seulement les contrats intelligents servent de bibliothèques open source, mais ce sont aussi essentiellement des services API ouverts fonctionnant / qui ne peuvent être arrêtés. Les contrats intelligents fournissent des fonctions publiques avec lesquelles les utilisateurs et les applications ([dApps](/developers/docs/dapps/)) peuvent interagir sans nécessiter d'autorisation. Toute application peut s'intégrer à des contrats intelligents déployés pour composer des fonctionnalités, telles que l'ajout de [flux de données](/developers/docs/oracles/) ou la prise en charge des échanges de jetons. N'importe qui peut déployer de nouveaux contrats intelligents sur Ethereum pour ajouter des fonctionnalités personnalisées et répondre aux besoins de son application. +Non seulement les contrats intelligents servent de bibliothèques open source, mais ce sont aussi essentiellement des services API ouverts fonctionnant 24/7 qui ne peuvent être arrêtés. Les contrats intelligents fournissent des fonctions publiques avec lesquelles les utilisateurs et les applications ([dApps](/developers/docs/dapps/)) peuvent interagir sans nécessiter d'autorisation. Toute application peut s'intégrer à des contrats intelligents déployés pour composer des fonctionnalités, telles que l'ajout de [flux de données](/developers/docs/oracles/) ou la prise en charge des échanges de jetons. N'importe qui peut déployer de nouveaux contrats intelligents sur Ethereum pour ajouter des fonctionnalités personnalisées et répondre aux besoins de son application. En tant que développeur de dApp, vous n'aurez besoin de rédiger des contrats intelligents que si vous voulez ajouter des fonctionnalités personnalisées sur la blockchain Ethereum. Vous constaterez que vous pouvez réaliser la plupart ou la totalité de vos projets seulement en intégrant des contrats intelligents existants, par exemple si vous voulez encourager les paiements en stablecoins ou faciliter l'échange décentralisé de jetons. @@ -42,7 +42,7 @@ De nombreuses bibliothèques pratiques (construites et maintenues par la communa Si votre application orientée utilisateur est une application Web, vous pouvez choisir de `npm install` une [API JavaScript](/developers/docs/apis/javascript/) directement sur votre frontend, ou préférerez peut-être implémenter cette fonctionnalité côté serveur, avec une API [Python](/developers/docs/programming-languages/python/) ou [Java](/developers/docs/programming-languages/java/). -Alors que ces API ne sont pas des éléments indispensables de la pile, elles éliminent une grande partie de la complexité d'intéragir directement avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex. convertir des ETH en gwei) afin que vous puissiez, en tant que développeur, passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous consacrer aux fonctionnalités uniques de votre application. +Alors que ces API ne sont pas des éléments indispensables de la pile, elles éliminent une grande partie de la complexité d'intéragir directement avec un nœud Ethereum. Elles fournissent également des fonctions utilitaires (par ex., convertir des ETH en gwei) afin que vous puissiez, en tant que développeur, passer moins de temps à gérer les subtilités des clients Ethereum et plus de temps à vous consacrer aux fonctionnalités uniques de votre application. ## Niveau 5 : Applications utilisateur {#end-user-applications} diff --git a/src/content/translations/fr/developers/docs/frameworks/index.md b/src/content/translations/fr/developers/docs/frameworks/index.md index 1b8208a9597..0a6d47d37ad 100644 --- a/src/content/translations/fr/developers/docs/frameworks/index.md +++ b/src/content/translations/fr/developers/docs/frameworks/index.md @@ -11,12 +11,12 @@ La construction d'une dApp complète nécessite différentes technologies. Les i Ces infrastructures sont livrés avec de nombreuses fonctionnalités prêtes à l'emploi : - Fonctionnalités pour faire tourner une instance locale de la blockchain. -- Des utilitaires pour compiler et tester vos contrats intelligents. +- Utilitaires pour compiler et tester vos contrats intelligents. - Modules de développement client pour construire votre application orientée utilisateur au sein du même projet/référentiel. - Configuration pour se connecter aux réseaux Ethereum et déployer des contrats, que ce soit sur une instance exécutée localement ou sur l'un des réseaux publics Ethereum. - Distribution d'applications décentralisées, intégration à des options de stockage comme IPFS. -## Pré-requis {#prerequisites} +## Prérequis {#prerequisites} Avant de plonger dans les infrastructures, nous vous recommandons de commencer par lire notre introduction aux [dApps](/developers/docs/dapps/) et à la [pile Ethereum](/developers/docs/ethereum-stack/). @@ -46,24 +46,29 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p - [Page d'accueil](https://www.web3labs.com/web3j-sdk) - [Documentation](https://docs.web3j.io) -- [GitHub](https://github.com/web3j/web3j) +- [Github](https://github.com/web3j/web3j) -**OpenZeppelin SDK -** **_La suite d'outils par excellence pour vous aider à développer, compiler, mettre à niveau, déployer et interagir avec des contrats intelligents._** +**OpenZeppelin SDK - \*\***_The Ultimate Smart Contract Toolkit : la suite d'outils par excellence pour vous aider à développer, compiler, mettre à niveau, déployer et interagir avec des contrats intelligents._\*\* - [OpenZeppelin SDK](https://openzeppelin.com/sdk/) -- [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk) +- [Github](https://github.com/OpenZeppelin/openzeppelin-sdk) - [Forum communautaire](https://forum.openzeppelin.com/c/support/17) -**Créer une application Eth -** **_Créer des applications alimentées par Ethereum avec une seule commande. Fournit un panel d'infrastructures d'interface utilisateur et des modèles DeFi parmi lesquels faire votre choix._** +**Create Eth App -** **_Création d'applications alimentées par Ethereum en une seule commande. Fournit un panel d'infrastructures d'interface utilisateur et des modèles DeFi parmi lesquels faire votre choix._** -- [GitHub](https://github.com/paulrberg/create-eth-app) -- [Modèles](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates) +- [Github](https://github.com/paulrberg/create-eth-app) +- [Modèles (Templates)](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates) **Scaffold-eth -** **_Les composants Ethers.js + Hardhat + React et les boucles pour web3 : tout ce dont vous avez besoin pour commencer à bâtir des applications décentralisées alimentées par des contrats intelligents._** - [GitHub](https://github.com/austintgriffith/scaffold-eth) -**Le graphique -** **_Le graphique pour interroger efficacement les données de la blockchain._** +**Probablement -** **_Plateforme de développement Web3 qui permet aux développeurs de blockchain de construire, tester, déboger, surveiller et gérer des contrats intelligents et améliorer la dApp UX._** + +- [Site Web](https://tenderly.co/) +- [Documentation](https://docs.tenderly.co/ethereum-development-practices) + +**The Graph -** **_Le graphique pour interroger efficacement les données de la blockchain._** - [Site Web](https://thegraph.com/) - [Tutoriel](/developers/tutorials/the-graph-fixing-web3-data-querying/) @@ -71,7 +76,7 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p **Alchemy -** **_Plateforme de développement Ethereum._** - [alchemy.com](https://www.alchemy.com/) -- [GitHub](https://github.com/alchemyplatform) +- [Github](https://github.com/alchemyplatform) - [Discord](https://discord.com/invite/A39JVCM) **Foundry -** **_Une boîte à outils rapide, portable et modulaire pour le développement d'applications Ethereum écrites en Rust._** @@ -80,6 +85,12 @@ Avant de plonger dans les infrastructures, nous vous recommandons de commencer p - [GitHub](https://github.com/gakonst/foundry/) - [Outils pour Foundry](https://github.com/crisgarner/awesome-foundry) +**NodeReal -** **_Plateforme de développement Ethereum._** + +- [Nodereal.io](https://nodereal.io/) +- [GitHub](https://github.com/node-real) +- [Discord](https://discord.gg/V5k5gsuE) + ## Complément d'information {#further-reading} _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ diff --git a/src/content/translations/fr/developers/docs/ides/index.md b/src/content/translations/fr/developers/docs/ides/index.md index 17adfe2359d..c8f49a73798 100644 --- a/src/content/translations/fr/developers/docs/ides/index.md +++ b/src/content/translations/fr/developers/docs/ides/index.md @@ -10,28 +10,31 @@ Lorsqu'il s'agit de configurer un [environnement de développement intégré (ID Si vous cherchez à manipuler du code avant de [configurer un environnement de développement local](/developers/local-environment/), ces applications Web sont conçues sur mesure pour le développement de contrats intelligents Ethereum. -**Remix -** **_IDE basé sur le Web avec analyse statique intégrée et une machine virtuelle de test de blockchain._** +**[Remix](https://remix.ethereum.org/)** - **_IDE basé sur le Web avec une analyse statique, et une machine virtuelle de test de la blockchain_** -- [remix.ethereum.org](https://remix.ethereum.org/) +- [Documentation](https://remix-ide.readthedocs.io/en/latest/#) +- [Gitter](https://gitter.im/ethereum/remix) -**EthFiddle -** **_IDE Web permettant de rédiger, de compiler et de déboguer vos contrats intelligents._** +**[ChainIDE](https://chainide.com/)** - **_Un IDE multichaîne basée sur le cloud_** -- [ethfiddle.com](https://ethfiddle.com/) -- [Gitter](https://gitter.im/loomnetwork/ethfiddle) +- [Documentation](https://chainide.gitbook.io/chainide-english-1/) +- [Forum d'aide](https://forum.chainide.com/) + +**[Replit (Starter Solidity - Beta)](https://replit.com/@replit/Solidity-starter-beta)** - **_Un environnement de développement personnalisable pour Ethereum avec rechargement, vérification d'erreur et support natif des réseaux de test._** -**ChainIDE -** **_IDE multi chaîne orienté Cloud_** +- [Documentation](https://docs.replit.com/) -- [chainide.com](https://chainide.com/) +**[Bac à sable Tenderly](https://sandbox.tenderly.co/)** - **_Un environnement de prototypage rapide où vous pouvez écrire, exécuter, et déboguer les contrats intelligents dans le navigateur en utilisant Solidity et JavaScript_** -**Replit : ** **_Un environnement de développement personnalisable pour Ethereum avec rechargement, vérification d'erreur et une assistance de première classe au réseau de tests._** +**[EthFiddle](https://ethfiddle.com/)** - **_IDE basé sur le Web qui vous permet d'écrire, de compiler et de déboguer votre contrat intelligent._** -- [Démarreur Solidity](https://replit.com/@replit/Solidity-starter-beta) +- [Gitter](https://gitter.im/loomnetwork/ethfiddle) ## IDE de bureau {#desktop-ides} -La plupart des IDE ont construit des plugins pour améliorer l'expérience de développement Ethereum. Au minimum, ils fournissent un éclairage syntaxique sur les [langages des contrats intelligents](/developers/docs/smart-contracts/languages/). +La plupart des IDE ont permis de construire des plugins pour améliorer l'expérience de développement Ethereum. Au minimum, ils fournissent un éclairage syntaxique sur les [langages des contrats intelligents](/developers/docs/smart-contracts/languages/). -**Visual Studio Code -** **_IDE professionnel multiplateforme avec support officiel Ethereum._** +**Visual Studio Code -** **_IDE professionnel multiplateforme avec le support officiel d'Ethereum._** - [Visual Studio Code](https://code.visualstudio.com/) - [Plan de travail blockchain Azure](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/microsoft-azure-blockchain.azure-blockchain-workbench?tab=Overview) @@ -58,6 +61,7 @@ La plupart des IDE ont construit des plugins pour améliorer l'expérience de d ## Plugins et extensions {#plugins-extensions} - [Solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - Ethereum Solidity Language for Visual Studio Code +- [Solidity + Hardhat pour VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - Prise en charge de Solidity et Hardhat par l'équipe Hardhat - [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - Formateur de code utilisant prettier ## Complément d'information {#further-reading} diff --git a/src/content/translations/fr/developers/docs/programming-languages/dart/index.md b/src/content/translations/fr/developers/docs/programming-languages/dart/index.md index e92b926938a..eaa11246a2e 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/dart/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/dart/index.md @@ -5,18 +5,18 @@ lang: fr incomplete: true --- -## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} +## Débuter avec les Contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} ## Tutos {#tutorials} -- [Flutter et blockchain – dApp Hello World](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) vous emmène à travers toutes les étapes pour bien débuter : +- [Flutter et blockchain – la dApp Hello World](https://www.geeksforgeeks.org/flutter-and-blockchain-hello-world-dapp/) vous emmène à travers toutes les étapes pour bien débuter : 1. Installer la suite de développement [Truffle](https://www.trufflesuite.com/) 2. Écrire un contrat intelligent avec [Solidity](https://soliditylang.org/) 3. Écrire une interface utilisateur avec Dart -- [Créer une dApp mobile avec Flutter](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) est beaucoup plus court, ce qui pourrait mieux convenir si vous connaissez déjà les bases. +- [Créer une dApp mobile avec Flutter](https://medium.com/dash-community/building-a-mobile-dapp-with-flutter-be945c80315a) est beaucoup plus court, ce qui pourrait mieux convenir si vous connaissez déjà les bases - Si vous préférez apprendre en regardant une vidéo, vous pouvez regarder [Elaborez votre première App Blockchain avec Flutter](https://www.youtube.com/watch?v=3Eeh3pJ6PeA), en une heure. - Si vous êtes impatient, vous préférerez peut-être [créer une application décentralisée blockchain avec Flutter et Dart sur Ethereum](https://www.youtube.com/watch?v=jaMFEOCq_1s), en seulement vingt minutes. -- [Intégrer MetaMask dans l'application Flutter](https://youtu.be/8qzVDje3IWk) - cette courte vidéo vous permet étape par étape d'intégrer MetaMask dans vos applications Flutte. +- [Intégrer MetaMask dans l'application Flutter](https://youtu.be/8qzVDje3IWk) - cette courte vidéo vous permet étape par étape d'intégrer MetaMask dans vos applications Flutter ## Travailler avec des clients Ethereum {#working-with-ethereum-clients} diff --git a/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md b/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md index c7b005d42e9..d193fc18c56 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/delphi/index.md @@ -11,7 +11,7 @@ Apprendre à développer pour Ethereum avec le langage de programmation Delphi -Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer. +Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer. Créez des applications décentralisées sur Ethereum et interagissez avec des contrats intelligents en utilisant le langage de programmation Delphi ! @@ -22,7 +22,7 @@ Créez des applications décentralisées sur Ethereum et interagissez avec des c Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/). - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) - [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) - [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) @@ -40,7 +40,7 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea - [Un contrat intelligent de 3 minutes et Delphi : 1ère partie](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-61d998571d) - [Un contrat intelligent de 3 minutes et Delphi : 2ème partie](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-part-2-446925faa47b) -## Articles de niveau intermédiaire {#intermediate-articles} +## Articles intermédiaires {#intermediate-articles} - [Génération d'une signature de message signée par Ethereum dans Delphi](https://medium.com/@svanas/generating-an-ethereum-signed-message-signature-in-delphi-75661ce5031b) - [Transfert d'éther avec Delphi](https://medium.com/@svanas/transferring-ether-with-delphi-b5f24b1a98a4) @@ -51,5 +51,6 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea - [Delphi et Ethereum Name Service (ENS)](https://medium.com/@svanas/delphi-and-ethereum-name-service-ens-4443cd278af7) - [QuikNode, Ethereum et Delphi](https://medium.com/@svanas/quiknode-ethereum-and-delphi-f7bfc9671c23) - [Delphi et la forêt sombre d'Ethereum](https://svanas.medium.com/delphi-and-the-ethereum-dark-forest-5b430da3ad93) +- [Échanger un jeton contre un autre avec Delphi](https://svanas.medium.com/swap-one-token-for-another-in-delphi-bcb999c47f7) Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/). diff --git a/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md b/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md index 46b5163e8ed..636412c4d2a 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/dot-net/index.md @@ -1,13 +1,13 @@ --- title: Ethereum pour les développeurs .NET -description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur .NET +description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur .NET lang: fr incomplete: true ---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur .NET
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer. +Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer. Construisez des applications décentralisées sur Ethereum et interagissez avec des contrats intelligents en utilisant les outils et les langages de la pile technologique Microsoft, qui prend en charge C#, # Visual Basic .NET, F# dans des environnements comme VSCode et Visual Studio sur .NET Framework/.NET Core/.NET Standard. Déployez une blockchain Ethereum sur Azure en quelques minutes en utilisant Microsoft Azure Blockchain. Continuez votre histoire d'amour avec .NET sur Ethereum ! @@ -18,7 +18,7 @@ Construisez des applications décentralisées sur Ethereum et interagissez avec Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/). - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) - [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) - [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) @@ -43,7 +43,7 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea - Transférer de l'ether sur un compte [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003) - ... Et bien plus encore ! -## Articles de niveau intermédiaire {#intermediate-articles} +## Articles intermédiaires {#intermediate-articles} - [Classeur/liste d'échantillons de Nethereum](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/) - [Déployer vos propres chaînes de test de développement](https://github.com/Nethereum/Testchains) @@ -68,7 +68,7 @@ Besoin d’une approche plus élémentaire ? Jetez un oeil à [ethereum.org/lea - [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) - _Générateur de code Nethereum C avec interface en Blazor_ - [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) - _Explorateur de blockchain Wasm SPA .NET léger et portefeuille simple_ - [Wonka Business Rules Engine](https://docs.nethereum.com/en/latest/wonka/) - _Moteur de règles commerciales (pour les plateformes .NET et Ethereum) intrinsèquement basé sur les métadonnées_ -- [Nethermind](https://github.com/NethermindEth/nethermind) - _Client Ethereum Core .NET pour Linux, Windows, MacOs_ +- [Nethermind](https://github.com/NethermindEth/nethermind) - _Client Ethereum Core .NET pour Linux, Windows, macOS_ - [eth-utils](https://github.com/ethereum/eth-utils/) - _Fonctions utilitaires pour travailler avec les bases de code liées à Ethereum_ - [TestChains](https://github.com/Nethereum/TestChains) - _Chaînes de développement .NET préconfigurées pour une réponse rapide (PoA)_ @@ -76,9 +76,9 @@ Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/d ## Contributeurs de la Communauté .NET {#dot-net-community-contributors} -Chez Nethereum, on se retrouve principalement sur [Gitter](https://gitter.im/Nethereum/Nethereum), où tout le monde est le bienvenu pour poser des questions et y répondre, obtenir de l'aide ou tout simplement se détendre. N'hésitez pas à faire une PR ou à ouvrir un ticket sur le dépôt [GitHub Nethereum](https://github.com/Nethereum), ou simplement à parcourir les nombreux projets/échantillons disponibles. Vous pouvez également nous trouver sur [Discord](https://discord.gg/jQPrR58FxX) ! +Chez Nethereum, on se retrouve principalement sur [Gitter](https://gitter.im/Nethereum/Nethereum), où tout le monde est le bienvenu pour poser des questions et y répondre, obtenir de l'aide ou tout simplement se détendre. N'hésitez pas à créer une PR ou à ouvrir un ticket sur le dépôt [GitHub Nethereum](https://github.com/Nethereum), ou simplement à parcourir les nombreux projets/échantillons disponibles. Vous pouvez également nous trouver sur [Discord](https://discord.gg/jQPrR58FxX) ! -Retrouvez Nethermind sur [Gitter](https://gitter.im/nethermindeth/nethermind). Pour tout problème ou PR, consultez le dépôt [GitHub Nethermind](https://github.com/NethermindEth/nethermind). +Si vous êtes nouveau chez Nethermind et avez besoin d'aide pour débuter, rejoignez notre [Discord](http://discord.gg/PaCMRFdvWT). Nos développeurs sont à votre disposition pour répondre à vos questions. N'hésitez pas à ouvrir une PR ou à signaler des problèmes sur le répertoire [GitHub de Nethermind](https://github.com/NethermindEth/nethermind). ## Autres ressources {#other-aggregated-lists} diff --git a/src/content/translations/fr/developers/docs/programming-languages/golang/index.md b/src/content/translations/fr/developers/docs/programming-languages/golang/index.md index e83a7625b8f..ac743a8ce9f 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/golang/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/golang/index.md @@ -1,13 +1,13 @@ --- title: Ethereum pour les développeurs Go -description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Go +description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Go lang: fr incomplete: true ---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Go
-Utilisez Ethereum pour créer des applications décentralisées (ou « dApps »). Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Étant décentralisées, elles fonctionnent sur un réseau P2P et il n'existe aucun point de défaillance. Aucune personne ni entité ne les contrôle, et il est pratiquement impossible de les censurer. Elles peuvent contrôler des actifs numériques afin de créer de nouveaux types d'applications. +Utilisez Ethereum pour créer des applications décentralisées (ou « dApps »). Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Étant décentralisées, elles fonctionnent sur un réseau P2P et il n'existe aucun point de défaillance. Aucune personne ni entité ne les contrôle, et il est pratiquement impossible de les censurer. Elles peuvent contrôler des actifs numériques afin de créer de nouveaux types d'applications. ## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} @@ -16,8 +16,8 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/). - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) -- [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Écrivez votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) - [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) - [Tutoriel de contrat](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial) @@ -33,11 +33,11 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le ## Articles et documentation de niveau intermédiaire {#intermediate-articles-and-docs} - [Documentation Go Ethereum](https://geth.ethereum.org/docs/) - _Documentation Ethereum officielle pour Go_ -- [Guide du programmeur Ergion](https://github.com/ledgerwatch/ergion/blob/devel/docs/programmers_guide/guide.md) - _Guide illustré incluant l'arborescence d'état, les multipreuves et le traitement des transactions_ -- [Erigon et Ethereum sans état](https://youtu.be/3-Mn7OckSus?t=394) - _Conférence de la communauté Ethereum 2020 (EthCC 3)_ -- [Erigon: optimiser les clients Ethereum](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _Devcon 4 - 2018 _ +- [Guide du programmeur Erigon](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _Guide illustré incluant l'arborescence d'état, les multipreuves et le traitement des transactions_ +- [Erigon et Ethereum sans état](https://youtu.be/3-Mn7OckSus?t=394) - _Conférence de la Communauté Ethereum 2020 (EthCC 3)_ +- [Erigon : optimiser les clients Ethereum](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _2018 Devcon 4_ - [GoDoc Go Ethereum](https://godoc.org/github.com/ethereum/go-ethereum) -- [Créer un dApp avec Geth dans Go](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/) +- [Créer une dApp avec Geth dans Go](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/) - [Travailler avec le réseau privé Ethereum avec Golang et Geth](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php) - [Test unitaire des contrats Solidity avec Go dans Ethereum](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281) - [Référence rapide pour utiliser Geth en tant que bibliothèque](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e) @@ -54,16 +54,17 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le - [Geth/Go Ethereum](https://github.com/ethereum/go-ethereum) - _Implémentation officielle du protocole Ethereum_ - [Go Ethereum Code Analysis](https://github.com/ZtesoftCS/go-ethereum-code-analysis) - _Revue et analyse du code source Go Ethereum_ -- [Erigon](https://github.com/ledgerwatch/erigon) - _Dérivé plus rapide de Go Ethereum_ +- [Erigon](https://github.com/ledgerwatch/erigon) - _Dérivé plus rapide de Go Ethereum, focalisé sur les nœuds d'archives_ - [Golem](https://github.com/golemfactory/golem) - _Golem crée un marché mondial de distribution de puissance informatique_ - [Quorum](https://github.com/jpmorganchase/quorum) - _Implémentation d'Ethereum soumise à droit d'accès, prenant en charge la confidentialité des données_ -- [Prysm](https://github.com/prysmaticlabs/prysm) - _Implémentation d'Ethereum « Serenity » 2.0 Go _ +- [Prysm](https://github.com/prysmaticlabs/prysm) - _Implémentation d'Ethereum « Serenity » 2.0 Go_ - [Eth Tweet](https://github.com/yep/eth-tweet) - _Twitter décentralisé : service de microblogging fonctionnant sur la blockchain Ethereum_ - [Plasma MVP Golang](https://github.com/kyokan/plasma) - _Implémentation et extension Golang de la spécification Minimum Viable Plasma_ - [Open Ethereum Mining Pool](https://github.com/sammy007/open-ethereum-pool) - _Groupe de minage Ethereum en open source_ - [Ethereum HD Wallet](https://github.com/miguelmota/go-ethereum-hdwallet) - _Dérivations de portefeuilles HD (Hierarchical Deterministic, ou déterministe hiérarchique) Ethereum en Go_ - [Multi Geth](https://github.com/multi-geth/multi-geth) - _Support pour de nombreux types de réseaux Ethereum_ - [Geth Light Client](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) - _Implémentation Geth du LES (Light Client Subprotocol) Ethereum_ +- [Ethereum Golang SDK](https://github.com/everFinance/goether) - _Une simple implémentation et des utilitaires pour les portefeuilles Ethereum dans Golang_ Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/) diff --git a/src/content/translations/fr/developers/docs/programming-languages/java/index.md b/src/content/translations/fr/developers/docs/programming-languages/java/index.md index eaa9a0444c8..eedf0751121 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/java/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/java/index.md @@ -1,13 +1,13 @@ --- title: Ethereum pour les développeurs Java -description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Java +description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java lang: fr incomplete: true ---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Java
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer. +Utilisez Ethereum pour créer des applications décentralisées (ou "DApps") qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces DApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer. ## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} @@ -16,7 +16,7 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dapp Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/) - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) - [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) - [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) @@ -33,7 +33,7 @@ Apprenez à utiliser [Web3J](https://github.com/web3j/web3j) et Hyperledger Besu - [Exécuter un nœud Hyperledger Besu (Pantheon) dans les tests d'intégration Java](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests) - [Mémo Web3j]() -## Articles de niveau intermédiaire {#intermediate-articles} +## Articles intermédiaires {#intermediate-articles} - [Gestion du stockage avec IPFS dans une application Java](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs) - [Gestion des jetons ERC20 avec Web3j dans Java](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j) diff --git a/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md b/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md index 453c23c241f..4be48af284b 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/javascript/index.md @@ -63,7 +63,7 @@ Plein d'autres choses voient le jour au pays d'Ethereum JavaScript, y compris : - des outils pour générer, importer et exporter des clés Ethereum ; - une implémentation du `merkle-patricia-tree`, une structure de données décrite dans le Livre jaune Ethereum. -Explorez ce qui vous intéresse le plus dans [EthereumJS](https://github.com/ethereumjs). +Explorez ce qui vous intéresse le plus dans le répertoire[EthereumJS](https://github.com/ethereumjs). ## Complément d'information {#further-reading} diff --git a/src/content/translations/fr/developers/docs/programming-languages/python/index.md b/src/content/translations/fr/developers/docs/programming-languages/python/index.md index 570e93c1114..859c0d6fc50 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/python/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/python/index.md @@ -1,13 +1,13 @@ --- title: Ethereum pour les développeurs Python -description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Python +description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Python lang: fr incomplete: true ---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Python
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer. +Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces DApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer. ## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} @@ -16,20 +16,21 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dapp Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/). - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) - [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) -- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) +- [Apprendre à compiler et à déployer une application avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) ## Articles pour les débutants {#beginner-articles} - [Guide du développeur (Python) pour Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/) -- [Introduction aux contrats intelligents avec Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/) +- [Rapport sur l'état de Python dans la blockchain 2023](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023) +- [An Introduction to Smart Contracts with Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/) - [Déployez votre propre jeton ERC20 avec Python et Brownie](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58) -- [Comment développer un contrat Ethereum avec Python Flask ?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e) -- [Intro à Web3.py · Ethereum pour les développeurs Python](https://www.dappuniversity.com/articles/web3-py-intro) -- [Comment appeler une fonction du contrat intelligent en utilisant Python et web3.py](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py) +- [How to develop Ethereum contract using Python Flask?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e) +- [Intro to Web3.py · Ethereum For Python Developers](https://www.dappuniversity.com/articles/web3-py-intro) +- [How to call a Smart Contract function using Python and web3.py](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py) -## Articles de niveau intermédiaire {#intermediate-articles} +## Articles intermédiaires {#intermediate-articles} - [Développement de dApp pour programmeurs Python](https://levelup.gitconnected.com/dapps-development-for-python-developers-f52b32b54f28) - [Création d'une interface Python Ethereum : 1ère partie](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d) @@ -48,9 +49,9 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le ### Actifs : {#active} - [Web3.py](https://github.com/ethereum/web3.py) - _Bibliothèque Python pour interagir avec Ethereum_ -- [Singe](https://github.com/ApeWorX/ape) - _L'outil de développement de contrats intelligents pour pythonistes, les data scientists et les professionnels de la sécurité_ -- [Brownie](https://github.com/eth-brownie/brownie) - _Infrastructure Python pour déployer et tester les contrats intelligents Ethereum, et interagir avec ces derniers_ - [Vyper](https://github.com/ethereum/vyper/) - _Langage des contrats intelligents en Python pour l'EVM_ +- [Ape](https://github.com/ApeWorX/ape) - _L'outil de développement de contrats intelligents pour les pythonistes, les data scientists et les professionnels de la sécurité_ +- [Brownie](https://github.com/eth-brownie/brownie) - _Infrastructure Python pour déployer et tester les contrats intelligents Ethereum, et interagir avec ces derniers_ - [py-evm](https://github.com/ethereum/py-evm) - _Implémentation de la machine virtuelle Ethereum_ - [eth-tester](https://github.com/ethereum/eth-tester) - _Outils pour tester des applications basées sur Ethereum_ - [eth-utils](https://github.com/ethereum/eth-utils/) - _Fonctions utilitaires pour travailler avec les bases de code liées à Ethereum_ @@ -59,7 +60,7 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le - [pydevp2p](https://github.com/ethereum/pydevp2p) - _Implémentation de la pile P2P Ethereum_ - [pymaker](https://github.com/makerdao/pymaker) - _API Python pour les contrats Maker_ - [siwe](https://github.com/spruceid/siwe-py) - _Connectez-vous avec Ethereum (siwe) pour Python_ -- [Contrats intelligents pour les tests](https://github.com/tradingstrategy-ai/smart-contracts-for-testing) - _Un paquet Python livré avec ERC-20, Uniswap et d'autres contrats courants pour l'écriture de tests avec Web3.py_ +- [Intégration Web3 DeFi pour Ethereum](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _Un paquet Python avec des intégrations prêtes à l'emploi pour ERC-20, Uniswap et d'autres projets populaires_ ### Archivé / Non entretenu : {#archived--no-longer-maintained} @@ -78,9 +79,10 @@ Les projets Ethereum suivants utilisent les outils mentionnés sur cette page. L - [Sushi](https://sushi.com/) utilise [Python pour gérer et déployer leurs contrats d'acquisition](https://github.com/sushiswap/sushi-vesting-protocols) - [Alpha Finance](https://alphafinance.io/), de la célèbre Alpha Homora, utilise [Brownie pour tester et déployer des contrats intelligents](https://github.com/AlphaFinanceLab/alpha-staking-contract) -## Contributeurs de la communauté Python {#python-community-contributors} +## Discussion de la Communauté Python {#python-community-contributors} -La communauté [Ethereum Python Discord](https://discord.gg/9zk7snTfWe) est l'hôte d'une communauté en pleine croissance et est la ressource dédiée pour discuter de l'un des projets ci-dessus et d'autres sujets connexes. +- [Discord de la Communauté Python Ethereum](https://discord.gg/9zk7snTfWe) pour la discussion sur Web3.py et autre framework Python +- [Vyper Discord](<[https://discord.gg/9zk7snTfWe](https://discord.gg/SdvKC79cJk)>) pour les discussions concernant la programmation avec Vyper des contrats intelligents ## Autres ressources {#other-aggregated-lists} diff --git a/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md b/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md index d4404969f00..ff0a46d30b3 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/ruby/index.md @@ -7,20 +7,20 @@ incomplete: false
Apprendre à développer sur Ethereum en utilisant des projets et des outils basés sur Ruby.
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dApps sont dignes de confiance, c'est-à-dire qu'une fois déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer. +Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, c'est-à-dire qu'une fois déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer. -## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} +## Débuter avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} **Commencer à intégrer Ruby avec Ethereum** Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/). - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) - [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) -- [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) +- [Apprendre à compiler et à déployer Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) -## Articles pour les débutants {#beginner-articles} +## Articles pour débutants {#beginner-articles} - [Bien comprendre les comptes Ethereum](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe) - [Authentifier les utilisateurs Rails avec MetaMask](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj) diff --git a/src/content/translations/fr/developers/docs/programming-languages/rust/index.md b/src/content/translations/fr/developers/docs/programming-languages/rust/index.md index 9390f315625..8f534bfadad 100644 --- a/src/content/translations/fr/developers/docs/programming-languages/rust/index.md +++ b/src/content/translations/fr/developers/docs/programming-languages/rust/index.md @@ -1,13 +1,13 @@ --- title: Ethereum pour les développeurs Rust -description: Apprendre à développer sur Ethereum avec des projets et des outils basés sur Rust +description: Apprendre à développer pour Ethereum avec des projets et des outils basés sur Rust lang: fr incomplete: true ---
Apprendre à développer pour Ethereum avec des projets et des outils basés sur Rust
-Utilisez Ethereum pour créer des applications décentralisées (ou « dapps ») qui bénéficient des avantages des crypto-monnaies et de la technologie blockchain. Ces dapps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune entité ou personne ne les contrôle et qu'il est pratiquement impossible de les censurer. +Utilisez Ethereum pour créer des applications décentralisées (ou « dApps ») qui tirent parti de la technologie de la blockchain et des cryptomonnaies. Ces dApps sont dignes de confiance, ce qui signifie que dès qu'elles sont déployées sur Ethereum, elles fonctionnent toujours comme prévu. Elles peuvent contrôler les actifs numériques afin de créer de nouveaux types d'applications financières. Elles peuvent être décentralisées, ce qui signifie qu'aucune personne ni entité ne les contrôle et qu'il est pratiquement impossible de les censurer. ## Premiers pas avec les contrats intelligents et le langage Solidity {#getting-started-with-smart-contracts-and-solidity} @@ -16,7 +16,7 @@ Utilisez Ethereum pour créer des applications décentralisées (ou « dapp Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/learn/) ou [ethereum.org/developers](/developers/). - [Explication de la blockchain](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained) -- [Comprendre les contrats autonomes](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) +- [Comprendre les contrats intelligents](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract) - [Écrire votre premier contrat intelligent](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract) - [Apprendre à compiler et à déployer avec Solidity](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment) @@ -28,35 +28,36 @@ Besoin d’une approche plus élémentaire ? Consultez [ethereum.org/learn](/le - [Une introduction aux contrats intelligents avec le client Ethereum Parity](https://wiki.parity.io/Smart-Contracts) - [Un tutoriel sur la façon d'écrire des contrats dans Rust Wasm pour Kovan](https://github.com/paritytech/pwasm-tutorial) -## Articles de niveau intermédiaire {#intermediate-articles} +## Articles intermédiaires {#intermediate-articles} ## Modèles d'utilisation avancés {#advanced-use-patterns} -- [bibliothèque externe pwasm_ethereum pour interagir avec un réseau de type Ethereum](https://github.com/openethereum/pwasm-ethereum) -- [Construire un chat décentralisé en utilisant JavaScript et Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52) -- [Construire une application Todo décentralisée en utilisant Vue.js et Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb) -- [Commencer avec Enigma : avec le langage de programmation Rust](https://blog.enigma.co/getting-started-with-discovery-the-rust-programming-language-4d1e0b06de15) -- [Introduction aux contrats secrets](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) +- [pwasm_ethereum externs library to interact with Ethereum-like network](https://github.com/openethereum/pwasm-ethereum) +- [Build A Decentralized Chat Using JavaScript and Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52) +- [Build a Decentralized Todo App Using Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb) + +- [An Intro to Secret Contracts](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) +- [Construire une blockchain en Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) ## Projets et outils Rust {#rust-projects-and-tools} - [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _Collection d'éléments externes pour interagir avec un réseau de type Ethereum_ - [Lighthouse](https://github.com/sigp/lighthouse) - _Client rapide de la couche de consensus d'Ethereum_ -- [Assemblée web d'Ethereum](https://ewasm.readthedocs.io/en/mkdocs/) +- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _Proposition de refonte de la couche d'exécution des contrats intelligents d'Ethereum en utilisant un sous-ensemble déterministe de WebAssembly_ - [oasis_std](https://docs.rs/oasis-std/0.2.7/oasis_std/) - _Référence de l'API OASIS_ -- [Solaris](https://github.com/paritytech/sol-rs) -- [SputnikVM](https://github.com/sorpaas/rust-evm) - _Implémentation en Rust de machines virtuelles Ethereum_ -- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contrats intelligents Wavelet en Rust_ +- [Solaris](https://github.com/paritytech/sol-rs) - _Exploiter le test unitaire des contrats intelligents Solidity utilisant l'EVM natif du client Parity._ +- [SputnikVM](https://github.com/rust-blockchain/evm) - _Implémentation en Rust de machines virtuelles Ethereum_ +- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contrats intelligents Wavelet sous Rust_ - [Foundry](https://github.com/gakonst/foundry)- _Boîte à outils pour le développement d'applications Ethereum_ - [Ethers_rs](https://github.com/gakonst/ethers-rs) - _Bibliothèque Ethereum et implémentation de portefeuille_ -- [evm_rs](https://github.com/rust-blockchain/evm) - _Implémentation de la machine virtuelle Ethereum en Rust_ - [SewUp](https://github.com/second-state/SewUp) - _Bibliothèque pour vous aider aussi bien à créer votre contrat Webassembly Ethereum avec Rust que développer un backend commun._ +- [Reth](https://github.com/paradigmxyz/reth) Reth (sous le nom de Rust Ethereum, en abrégé Reth, prononciation) : il s'agit d'une nouvelle implémentation de nœud complet sur Ethereum Vous cherchez davantage de ressources ? Consultez [ethereum.org/developers.](/developers/) ## Contributeurs de la communauté Rust {#rust-community-contributors} -- [WebAssembly Ethereum](https://gitter.im/ewasm/Lobby) +- [Ethereum WebAssembly](https://gitter.im/ewasm/Lobby) - [Gitter d'Oasis](https://gitter.im/Oasis-official/Lobby) - [Gitter de Parity](https://gitter.im/paritytech/parity) - [Enigma](https://discord.gg/SJK32GY) diff --git a/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md b/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md index 2e5a122f0dc..e9864f02465 100644 --- a/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md +++ b/src/content/translations/fr/developers/docs/smart-contracts/anatomy/index.md @@ -639,7 +639,7 @@ contract CryptoPizza is IERC721, ERC165 { } ``` -## En lire plus {#further-reading} +## Complément d'information {#further-reading} Consultez la documentation Solidity et Vyper pour une vue d'ensemble plus complète des contrats intelligents : diff --git a/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md b/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md index fc9d2c5cfd2..a5dcb5fedda 100644 --- a/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md +++ b/src/content/translations/fr/developers/docs/smart-contracts/compiling/index.md @@ -1,5 +1,5 @@ --- -title: Compiler des contrats intelligents +title: Compiler des contrat intelligents description: Explication de la raison d'une compilation et pourquoi elle est nécessaire pour les contrats intelligents lang: fr incomplete: true @@ -275,4 +275,4 @@ Vous trouverez ci-dessous l’ABI pour le contrat de jetons ERC-20. Un jeton ERC ## Sujets connexes {#related-topics} - [Bibliothèques clientes JavaScript](/developers/docs/apis/javascript/) -- [Machine virtuelle Ethereum (EVM)](/developers/docs/ethereum-virtual-machine/) +- [Machine virtuelle Ethereum (EVM)](/developers/docs/evm/) diff --git a/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md b/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md index dadd66c6714..aee467780a8 100644 --- a/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md +++ b/src/content/translations/fr/developers/docs/smart-contracts/deploying/index.md @@ -1,5 +1,5 @@ --- -title: Déployer des contrats intelligents +title: Déployer des contrat intelligents description: lang: fr --- @@ -12,7 +12,7 @@ Déployer un contrat intelligent consiste à envoyer sur la blockchain une trans Il est préférable d'avoir compris en quoi consiste les [réseaux Ethereum](/developers/docs/networks/), les [transactions](/developers/docs/transactions/) et l'[anatomie des contrats intelligents](/developers/docs/smart-contracts/anatomy/) avant de déployer des contrats intelligents. -Le déploiement d'un contrat coûte également des ethers, nous vous recommandons donc de vous familiariser avec le [gaz et les frais](/developers/docs/gas/) sur Ethereum. +Le déploiement d'un contrat coûte également de l'éther (ETH) puisqu'il est stocké sur la blockchain, vous devez donc être familiarisé avec [le gaz et les frais](/developers/docs/gas/) sur Ethereum. Enfin, comme vous devrez compiler votre contrat avant de le déployer, assurez-vous d'avoir lu la page sur la [compilation des contrats intelligents](/developers/docs/smart-contracts/compiling/). @@ -23,7 +23,7 @@ Enfin, comme vous devrez compiler votre contrat avant de le déployer, assurez-v - Le bytecode du contrat, généré par la [compilation](/developers/docs/smart-contracts/compiling/). - Des ethers pour le gaz. Vous fixerez votre limite de gaz comme pour les autres transactions, mais sachez que les déploiements de contrats nécessitent beaucoup plus de gaz qu'un simple transfert d'ethers. - Un script de déploiement ou un plugin. -- l'accès à un [nœud Ethereum](/developers/docs/nodes-and-clients/), soit en créant le vôtre, soit en vous connectant à un nœud public, soit via un [service de nœuds](/developers/docs/nodes-and-clients/nodes-as-a-service/) comme Infura ou Alchemy avec une clé d'API +- l'accès à un [nœud Ethereum](/developers/docs/nodes-and-clients/), soit en créant le vôtre, soit en vous connectant à un nœud public, soit via un [service de nœuds](/developers/docs/nodes-and-clients/nodes-as-a-service/) avec une clé d'API ### Étapes pour déployer un contrat intelligent {#steps-to-deploy} @@ -37,7 +37,7 @@ Une fois déployé, votre contrat aura une adresse Ethereum comme les autres [co - [Remix](https://remix.ethereum.org) -**Tenderly - _Simuler, déboguer et surveiller quoi que ce soit sur des chaînes compatibles EVM, avec des données en temps réel_** +**Tenderly - _ - Plateforme de développement Web3 qui fournit des blocs de débogage, d'observabilité et de construction d'infrastructures en vue de l'élaboration, de la mise à l'essai, du suivi et de l'exécution de contrats intelligents_** - [tenderly.co](https://tenderly.co/) - [Documentation](https://docs.tenderly.co/) @@ -60,8 +60,9 @@ Une fois déployé, votre contrat aura une adresse Ethereum comme les autres [co ## Tutoriels connexes {#related-tutorials} - [Déployer votre premier contrat intelligent](/developers/tutorials/deploying-your-first-smart-contract/) _– Introduction au déploiement de votre premier contrat intelligent sur un réseau de test Ethereum_ +- [Hello World | Un tutoriel sur le contrat intelligent](/developers/tutorials/hello-world-smart-contract/) _– Un tutoriel facile à suivre pour créer, & déployer un contrat intelligent de base sur Ethereum._ - [Interagir avec d'autres contrats Solidity](/developers/tutorials/interact-with-other-contracts-from-solidity/) _- Comment déployer et interagir avec un contrat intelligent à partir d'un contrat existant_ -- [Réduire les contrats pour respecter la limite de taille](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _- Comment réduire la taille de votre contrat pour le garder sous la limite et économiser du gaz_ +- [Comment réduire la taille de votre contrat](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _- Comment réduire la taille de votre contrat pour le garder sous la limite et économiser du gaz_ ## Complément d'information {#further-reading} @@ -74,3 +75,4 @@ _Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ - [Infrastructures de développement](/developers/docs/frameworks/) - [Exécuter un nœud Ethereum](/developers/docs/nodes-and-clients/run-a-node/) +- [Nœuds en tant que service](/developers/docs/nodes-and-clients/nodes-as-a-service) diff --git a/src/content/translations/fr/developers/docs/smart-contracts/index.md b/src/content/translations/fr/developers/docs/smart-contracts/index.md index 35bf966dc02..ac87a89bb8b 100644 --- a/src/content/translations/fr/developers/docs/smart-contracts/index.md +++ b/src/content/translations/fr/developers/docs/smart-contracts/index.md @@ -8,9 +8,9 @@ lang: fr Un "contrat intelligent" est simplement un programme exécuté sur la blockchain d'Ethereum. C'est un ensemble de code (ses fonctions) et de données (son état) qui réside à une adresse spécifique sur la blockchain Ethereum. -Le contrat intelligent est un type de [compte Ethereum](/developers/docs/accounts/). Cela signifie qu'il dispose d'un solde et peut envoyer des transactions sur le réseau. Cependant, il n'est pas contrôlé par un utilisateur, mais est plutôt déployé et exécuté comme un programme. Les comptes des utilisateurs peuvent ensuite interagir avec un contrat intelligent en soumettant des transactions qui exécutent une fonction définie sur le contrat intelligent. Un contrat intelligent peut définir des règles, comme un contrat normal, et les appliquer automatiquement via le code. Les contrats intelligents ne peuvent pas être supprimés par défaut et les interactions avec eux sont irréversibles. +Le contrat intelligent est un type de [compte Ethereum](/developers/docs/accounts/). Ceci veut dire qu'ils ont un solde et peuvent être la cible de transactions. Cependant, il n'est pas contrôlé par un utilisateur, mais est plutôt déployé et exécuté comme un programme. Les comptes des utilisateurs peuvent ensuite interagir avec un contrat intelligent en soumettant des transactions qui exécutent une fonction définie sur le contrat intelligent. Un contrat intelligent peut définir des règles, comme un contrat normal, et les appliquer automatiquement via le code. Les contrats intelligents ne peuvent pas être supprimés par défaut et les interactions avec eux sont irréversibles. -## Pré-requis {#prerequisites} +## Prérequis {#prerequisites} Si vous venez tout juste de débuter ou si vous cherchez une introduction moins technique, nous vous recommandons notre [introduction aux contrats intelligents](/smart-contracts/). @@ -28,7 +28,7 @@ money + snack selection = snack dispensed Cette logique est programmée dans les distributeurs automatiques. -Le contrat intelligent, comme un distributeur automatique, possède une logique programmée. Voici un exemple simple de la façon dont ce distributeur automatique pourrait ressembler à un contrat intelligent : +Le contrat intelligent, comme un distributeur automatique, possède une logique programmée. Voici un exemple simple de ce à quoi ce distributeur automatique pourrait ressembler s'il était un contrat intelligent rédigé avec Solidity : ```solidity pragma solidity 0.8.7; @@ -67,7 +67,7 @@ Tout comme un distributeur automatique peut remplacer un employé dans une bouti ## Sans autorisation {#permissionless} -N'importe qui peut rédiger un contrat intelligent et le déployer sur le réseau. Il vous suffit d'apprendre à coder dans un [langage de contrat intelligent](/developers/docs/smart-contracts/languages/) et de disposer de suffisamment d'ETH pour déployer votre contrat. Techniquement, le fait de déployer un contrat intelligent constitue une transaction. Vous devez donc payer pour le [carburant](/developers/docs/gas/), comme vous le feriez pour un simple transfert d'ETH. Les coûts en gaz requis pour déployer un contrat sont cependant beaucoup plus élevés. +N'importe qui peut rédiger un contrat intelligent et le déployer sur le réseau. Il vous suffit d'apprendre à coder dans un [langage de contrat intelligent](/developers/docs/smart-contracts/languages/) et de disposer de suffisamment d'ETH pour déployer votre contrat. Techniquement, le fait de déployer un contrat intelligent est une transaction. L'auteur doit donc payer des frais de [Gaz](/developers/docs/gas/) de la même façon qu'il s'acquitterait de ces frais pour un simple transfert d'ETH. Toutefois, les frais de gaz pour le déploiement d'un contrat sont beaucoup plus élevés. Pour la rédaction des contrats intelligents, Ethereum propose aux développeurs des langages conviviaux : @@ -80,7 +80,7 @@ Toutefois, pour que la machine virtuelle Ethereum puisse interpréter et stocker ## Composabilité {#composability} -Sur Ethereum, les contrats intelligents sont publics. Ils peuvent être considérés comme des API ouvertes. Cela signifie que vous pouvez appeler d'autres contrats intelligents dans votre propre contrat afin d'étendre considérablement les possibilités. Certains d'entre eux peuvent même déployer d'autres contrats. +Sur Ethereum, les contrats intelligents sont publics. Ils peuvent être considérés comme des API ouvertes. Cela signifie que vous pouvez appeler d'autres contrats intelligents dans votre propre contrat afin d'en étendre considérablement les fonctionnalités. Certains d'entre eux peuvent même déployer d'autres contrats. En savoir plus sur la [composabilité des contrats intelligents](/developers/docs/smart-contracts/composability/). @@ -92,9 +92,13 @@ Il existe des moyens de contourner le problème en utilisant [oracles](/develope Une autre limitation des contrats intelligents est la taille maximale des contrats. Un contrat intelligent ne peut pas dépasser 24 Ko, sans quoi il sera à court de gaz. Ceci peut être contourné en utilisant [Le modèle du diamant](https://eips.ethereum.org/EIPS/eip-2535). +## Contrats Multisig {#multisig} + +Les contrats multisig (signature multiple) sont des comptes de contrats intelligents nécessitant plusieurs signatures valides pour exécuter une transaction. C'est très utile afin d'éviter les points de défaillance unique pour les contrats contenant des montants conséquents d'ether ou autres tokens. Les signatures multiples partagent la responsabilité d'exécution du contact ainsi que la gestion des clés entre plusieurs parties et évite la perte d'une unique clé privée amenant à la perte irréversible des fonds. Pour ces raisons, les contrats multisig peuvent être utilisés pour la simple gouvernance d'une DAO. La signature multiple requiert N signatures parmi M signatures possibles (où N ≤ M, et M > 1) pour permettre l'exécution. `N = 3, M = 5` et `N = 4, M = 7` sont assez répandus. Une multi-signature 4/7 requiert quatre signatures valides sur les sept possibles. Cela signifie que les fonds restent récupérables même si trois signatures sont perdues. Dans ce cas, cela signifie également que la majorité des détenteurs de clés doivent accepter et signer pour que le contrat puisse être exécuté. + ## Ressources de contrats intelligents {#smart-contract-resources} -**Contrats OpenZeppelin -** **_Bibliothèque la plus populaire pour développer des contrats intelligents de façon sécurisée_** +**Contrats OpenZeppelin -** **_Bibliothèque pour développer des contrats intelligents de façon sécurisée_** - [openzeppelin.com/contracts/](https://openzeppelin.com/contracts/) - [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts) diff --git a/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md b/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md index 7998c091cb5..8f8e1aba8f8 100644 --- a/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md +++ b/src/content/translations/fr/developers/docs/smart-contracts/languages/index.md @@ -1,5 +1,5 @@ --- -title: Langages du contrat intelligent +title: Les langages des contrats intelligents description: "Présentation et comparaison des deux principaux langages de contrat intelligent : Solidity et Vyper" lang: fr --- @@ -88,13 +88,14 @@ Cet exemple devrait vous donner une idée de la syntaxe d'un contrat Solidity. P - Langage de programmation pythonique - Typage fort - Code de compilation concis et compréhensible -- A intentionnellement moins de fonctionnalités que Solidity dans le but de rendre les contrats plus sécurisés et plus faciles à auditer . Vyper ne prend pas en charge les éléments suivants : +- Génération efficace du bytecode +- A intentionnellement moins de fonctionnalités que Solidity dans le but de rendre les contrats plus sécurisés et plus faciles à auditer. Vyper ne prend pas en charge les éléments suivants : - Modificateurs - Héritage - Assemblage en ligne - Surcharge des fonctions - Surcharge d’opérateur - - Appels récurrent + - Appels récurrents - Boucles infinies - Points fixes binaires @@ -103,11 +104,17 @@ Pour plus d'informations, [lisez cette page Vyper](https://vyper.readthedocs.io/ ### Liens importants {#important-links-1} - [Documentation](https://vyper.readthedocs.io) -- [Vyper by Example](https://vyper.readthedocs.io/en/latest/vyper-by-example.html) +- [Vyper par exemple](https://vyper.readthedocs.io/en/latest/vyper-by-example.html) +- [Plus de Vyper par exemple](https://vyper-by-example.org/) - [GitHub](https://github.com/vyperlang/vyper) -- [Chatroom Gitter Vyper](https://gitter.im/vyperlang/community) +- [Discussion Discord pour la Communauté Vyper](https://discord.gg/SdvKC79cJk) - [Cheat Sheet](https://reference.auditless.com/cheatsheet) -- [Mise à jour du 8 janvier 2020](https://blog.ethereum.org/2020/01/08/update-on-the-vyper-compiler) +- [Cadres et outils de développement des Contrats intelligents pour Vyper](/developers/docs/programming-languages/python/) +- [VyperPunk - apprendre à sécuriser et à pirater les contrats intelligents Vyper](https://github.com/SupremacyTeam/VyperPunk) +- [VyperExamples - exemples de vulnérabilités Vyper](https://www.vyperexamples.com/reentrancy) +- [Hub Vyper pour le développement](https://github.com/zcor/vyper-dev) +- [Exemples des meilleurs contrats intelligents pour Vyper](https://github.com/pynchmeister/vyper-greatest-hits/tree/main/contracts) +- [Des ressources géniales liées à Vyper](https://github.com/spadebuilders/awesome-vyper) ### Exemple {#example} @@ -206,7 +213,7 @@ Si vous débutez avec Ethereum et que vous n'avez pas encore jamais codé avec d - Langage intermédiaire pour Ethereum - Prends en charge l'[EVM](/developers/docs/evm) et l'[Ewasm](https://github.com/ewasm), un assemblage Web au petit goût d'Ethereum conçu pour être un dénominateur commun utilisable sur les deux plateformes. -- Excellente cible pour les phases d'optimisation de haut niveau qui peuvent bénéficier à la fois aux plateformes EVM et Ewasm. +- Excellente cible pour les phases d'optimisation de haut niveau qui peuvent bénéficier à la fois aux plateformes EVM et eWASM. **Yul+** diff --git a/src/content/translations/fr/developers/docs/smart-contracts/security/index.md b/src/content/translations/fr/developers/docs/smart-contracts/security/index.md index 4fcabef1895..287bd5892ef 100644 --- a/src/content/translations/fr/developers/docs/smart-contracts/security/index.md +++ b/src/content/translations/fr/developers/docs/smart-contracts/security/index.md @@ -1,148 +1,246 @@ --- title: Sécurité des contrats intelligents -description: Considérations de sécurité pour les développeurs Ethereum +description: Un aperçu des lignes directrices pour la construction de contrats intelligents sécurisés Ethereum lang: fr --- -Les contrats intelligents Ethereum sont extrêmement flexibles, capables à la fois de détenir de grandes quantités de jetons (souvent plus de 1 milliard de $) et d'exécuter une logique immuable sur du code intelligent précédemment déployé. Alors que cela a créé un écosystème dynamique et créatif de contrats intelligents interconnectés et trustless, c'est aussi l'écosystème parfait pour attirer les attaquants qui cherchent à en tirer profit en exploitant des vulnérabilités dans les contrats intelligents et des comportements inattendus dans Ethereum. Le code d'un contrat intelligent ne peut _habituellement_ pas être modifié pour corriger les défauts de sécurité, les actifs volés à partir de contrats intelligents sont irrécupérables et extrêmement difficiles à tracer. Le montant total des sommes volées ou perdues en raison de problèmes sur les contrats intelligents atteint facilement le milliard de dollars. Voici quelques-uns des problèmes les plus importants dus à des erreurs de codage de contrat intelligent : +Les contrats intelligents sont extrêmement flexibles et capables de contrôler de grandes quantités de valeur et de données, tout en exécutant une logique immuable basée sur le code déployé sur la blockchain. Cela a créé un écosystème dynamique d’applications sans tiers de confiance et décentralisées qui offrent de nombreux avantages par rapport aux systèmes existants. Ils représentent également des opportunités pour les attaquants qui cherchent à tirer profit de vulnérabilités dans les contrats intelligents. -- [Problème n°1 de multisig Parity - 30 millions de dollars perdus](https://www.coindesk.com/30-million-ether-reported-stolen-parity-wallet-breach) -- [Problème n°2 de multisig Parity - 300 millions de dollars perdus](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether) -- [Hack TheDAO, 3,6 millions d'ETH ! Prés de 1 milliard de dollars en prix actuel de l'ETH](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) +Les blockchains publiques, comme Ethereum, compliquent encore davantage la question de la sécurisation des contrats intelligents. Le code de contrat déployé ne peut _généralement_ pas être modifié pour corriger des défauts de sécurité, et les actifs volés sur des contrats intelligents sont extrêmement difficiles à suivre et la plupart du temps irrécupérables en raison de l’immuabilité. + +Bien que les chiffres varient, on estime que le montant total de la valeur volée ou perdue en raison de défauts de sécurité dans les contrats intelligents est d'au moins 1 milliard de dollars. Cela inclut des incidents de haut niveau, tels que [le hack de DAO](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) (3,6 millions d'ETH volés, d'une valeur de plus de 1 milliard de dollars aux prix actuels), [le hack du portefeuille multi-sig Parity](https://www.coindesk.com/30-million-ether-reported-stolen-parity-wallet-breach) (30 millions de dollars volés par les hackeurs), et [le problème du portefeuille gelé Parity](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether) (plus de 300 millions de dollars en ETH verrouillés pour toujours). + +Les problèmes susmentionnés rendent impératif pour les développeurs d'investir des efforts dans la construction de contrats intelligents sécurisés, robustes et résistants. La sécurité des contrats intelligents est une affaire sérieuse, que chaque développeur ferait bien d’apprendre. Ce guide couvrira les considérations de sécurité des développeurs Ethereum et explorera les ressources pour améliorer la sécurité des contrats intelligents. ## Prérequis {#prerequisites} -Cette page couvre la sécurité des contrats intelligents, donc assurez-vous d'être familiarisé avec les [contrats intelligents](/developers/docs/smart-contracts/) avant d'aborder la sécurité. +Assurez-vous de vous familiariser avec les [fondamentaux du développement de contrats intelligent](/developers/docs/smart-contracts/) avant de vous attaquer à la sécurité. -## Comment écrire un code de contrats intelligents plus sécurisé {#how-to-write-more-secure-smart-contract-code} +## Lignes directrices pour la construction de contrats intelligents sécurisés Ethereum {#smart-contract-security-guidelines} -Avant de lancer un code sur le réseau principal, il est important de prendre des précautions suffisantes pour protéger tout ce qui a de la valeur et qui est confié à votre contrat intelligent. Dans cet article, nous allons discuter de quelques attaques spécifiques, fournir des ressources pour en savoir plus sur les types d'attaques, et vous donner quelques outils et bonnes pratiques de base pour assurer le bon fonctionnement et la sécurité de vos contrats. +### 1. Concevoir des contrôles d'accès appropriés {#design-proper-access-controls} -## Les audits ne sont pas une solution miracle {#audits-are-not-a-silver-bullet} +Dans les contrats intelligents, les fonctions marquées `publiques` ou `externes` peuvent être appelées par n'importe quel compte externe (EOA) ou compte de contrat. Il est nécessaire de spécifier une visibilité publique des fonctions si vous voulez que les autres interagissent avec votre contrat. Les fonctions marquées `privées` ne peuvent cependant être appelées que par des fonctions au sein du contrat intelligent, et non par des comptes externes. Donner à chaque participant au réseau un accès aux fonctions du contrat peut causer des problèmes, surtout si cela signifie que n'importe qui peut effectuer des opérations sensibles (par exemple, frapper de nouveaux jetons). -Il y a des années, les outils permettant d'écrire, de compiler, de tester et de déployer des contrats intelligents manquaient de maturité, ce qui a généré de nombreux projets désordonnés d'écriture de code Solidity, code qui était ensuite transmis à un expert pour examen afin de s'assurer qu'il fonctionnait de façon sécurisée et comme prévu. En 2020, les processus de développement et les outils qui prennent en charge l'écriture de Solidity sont nettement meilleurs. En exploiter les bonnes pratiques permet non seulement de garantir que votre projet est plus facile à gérer, mais cela constitue un élément essentiel de sa sécurité. Un audit en fin de rédaction de votre contrat intelligent ne suffit plus comme seule considération de sécurité. La sécurité commence bien avant d'écrire votre première ligne de code de contrat intelligent, **elle commence par des processus de conception et de développement adéquats**. +Pour éviter l'utilisation non autorisée de fonctions de contrats intelligents, il est nécessaire de mettre en place des contrôles d'accès sécurisés. Les mécanismes de contrôle d'accès restreignent la capacité d'utiliser certaines fonctions dans un contrat intelligent à des entités approuvées, comme les comptes responsables de la gestion du contrat. Le **modèle Ownable** et **le contrôle d'accès basé sur les rôles** sont deux pratiques utiles pour implémenter le contrôle d'accès dans les contrats intelligents : -## Processus de développement de contrats intelligents {#smart-contract-development-process} +#### Modèle Ownable {#ownable-pattern} -Il faut au minimum que : +Dans le modèle Ownable, une adresse est définie comme « propriétaire » du contrat au cours du processus de création du contrat. Les fonctions protégées sont assignées avec un modificateur `OnlyOwner` , qui assure que le contrat authentifie l'identité de l'adresse d'appel avant d'exécuter la fonction. Les appels à des fonctions protégées à partir d'autres adresses en dehors du propriétaire du contrat s'annulent toujours, empêchant l'accès non désiré. -- tout le code soit stocké dans un système de contrôle de version comme git ; -- toutes les modifications de code soient effectuées via des PR (Pull Requests) ; -- toutes les PR aient au moins un réviseur ; _Si vous travaillez sur un projet en solo, envisagez de trouver un autre auteur solo pour négocier des révisions de code !_ -- une seule commande compile, déploie et exécute une suite de tests sur votre code en utilisant un environnement de développement Ethereum (Voir : Truffle) ; -- vous ayez exécuté votre code via des outils d'analyse basiques comme Mythril et Slither, idéalement avant que chaque PR soit fusionnée, en comparant les différences de sortie ; -- Solidity n'émette aucune alerte à la compilation ; -- votre code soit bien documenté. +#### Contrôle d'accès basé sur les rôles {#role-based-access-control} -Il y a bien d'autres choses à dire sur les processus de développement, mais ces éléments constituent un bon point de départ. Pour plus d'éléments et d'explications détaillées, consultez la [liste de contrôle qualité des processus, fournie par DeFiSafety](https://docs.defisafety.com/review-process-documentation/process-quality-audit-process). [DefiSafety](https://defisafety.com/) est un service public non officiel qui publie des avis sur diverses DApps Ethereum publiques de grande taille. Une partie du système d'évaluation de DeFiSafety comprend la façon dont le projet adhère à cette liste de contrôle qualité des processus. En suivant ces processus : +L'enregistrement d'une seule adresse en tant que `Owner` dans un contrat intelligent introduit un risque de centralisation et représente un point de défaillance unique. Si les clés de compte du propriétaire sont compromises, des attaquants peuvent attaquer le contrat détenu. C'est pourquoi utiliser un modèle de contrôle d'accès basé sur des rôles avec plusieurs comptes administratifs peut être une meilleure solution. -- vous produirez du code plus sécurisé, via des tests reproductibles et automatisés ; -- les experts seront en mesure de vérifier votre projet plus efficacement ; -- l'intégration de nouveaux développeurs sera plus simple ; -- les développeurs pourront itérer, tester et obtenir des commentaires sur les modifications rapidement ; -- votre projet enregistrera probablement moins de régressions. +Dans le cadre du contrôle d'accès basé sur les rôles, l'accès aux fonctions sensibles est réparti entre un ensemble de participants de confiance. Par exemple, un compte peut être responsable de la frappe des jetons, tandis qu'un autre compte peut effectuer des mises à niveau ou interrompre le contrat. Décentraliser le contrôle d'accès de cette façon élimine les points de défaillance uniques et réduit les hypothèses de confiance pour les utilisateurs. -## Attaques et vulnérabilités {#attacks-and-vulnerabilities} +##### Utilisation de portefeuilles multi-signature -Maintenant que vous écrivez du code Solidity en utilisant un processus de développement efficace, examinons quelques vulnérabilités courantes de Solidity pour voir ce qui peut mal tourner. +Une autre approche pour implémenter un contrôle d'accès sécurisé est d'utiliser un [compte multi-signature](/developers/docs/smart-contracts/#multisig) pour gérer un contrat. Contrairement à un EOA habituel, les comptes multi-signature sont détenus par plusieurs entités et nécessitent les signatures d'un nombre minimum de comptes — disons de 3 sur 5 — pour exécuter des transactions. -### Réentrance {#re-entrancy} +L'utilisation d'un portefeuille multi-signature pour le contrôle d'accès introduit une couche de sécurité supplémentaire dans la mesure où les actions sur le contrat cible nécessitent le consentement de plusieurs parties. Ceci est particulièrement utile si l'utilisation du modèle Ownable est nécessaire, car il rend plus difficile pour un attaquant ou un initié malhonnête de manipuler des fonctions sensibles du contrat à des fins malveillantes. -La réentrance est l'un des problèmes de sécurité les plus importants à considérer lors du développement de contrats intelligents. L'EVM ne pouvant pas exécuter plusieurs contrats en même temps, un contrat appelant un autre contrat met en pause l'exécution du contrat appelant et l'état de la mémoire jusqu'à ce que l'appel revienne, événement à partir duquel l'exécution reprend normalement. Cette pause et cette reprise peuvent créer une vulnérabilité connue sous le nom de "réentrance". +### 2. Utiliser les commandes require(), assert() et revert() pour protéger les opérations de contrat {#use-require-assert-revert} -Voici une version simple d'un contrat vulnérable à la réentrance : +Comme mentionné, n'importe qui peut appeler des fonctions publiques de votre contrat intelligent une fois qu'il est déployé sur la blockchain. Comme vous ne pouvez pas savoir à l'avance comment les comptes externes interagiront avec un contrat, il est idéal de mettre en œuvre des protections internes contre les opérations problématiques avant le déploiement. Vous pouvez imposer un comportement correct dans les contrats intelligents en utilisant les fonctions `require()`, `assert()`, et `revert()` pour déclencher des exceptions et annuler les changements d'état si l'exécution ne répond pas à certaines exigences. -```solidity -// CE CONTRAT A UNE VULNÉRABILITÉ INTENTIONNELLE, NE PAS COPIER -contract Victim { - mapping (address => uint256) public balances; +**`require()`** : `require` sont définis en début de fonction et cela garantit que des conditions prédéfinies sont remplies avant l'exécution de la fonction appelée. Une instruction `require` peut être utilisée pour valider les entrées utilisateur, vérifier les variables d'état, ou authentifier l'identité du compte appelant avant d'exécuter la fonction. - function deposit() external payable { - balances[msg.sender] += msg.value; +**`assert()`**: `assert()` est utilisée pour détecter les erreurs internes et vérifier les violations des « invariants » dans votre code. Un invariant est une assertion logique à propos de l’état d’un contrat qui devrait être vrai pour toutes les exécutions de fonctions. Un exemple d'invariant est la quantité maximale totale ou le solde d'un contrat de jeton. L'utilisation de la fonction `assert()` garantit que votre contrat n'atteint jamais un état vulnérable, et si c'est le cas malgré tout que toutes les modifications apportées aux variables d'état sont annulées. + +**`revert()`** : `revert()` peut être utilisé dans une instruction if-else qui déclenche une exception si la condition demandée n'est pas satisfaite. L'exemple de contrat ci-dessous utilise `revert()` pour proteger l'exécution des fonctions : + +``` +pragma solidity ^0.8.4; + +contract VendingMachine { + address owner; + error Unauthorized(); + function buy(uint amount) public payable { + if (amount > msg.value / 2 ether) + revert("Not enough Ether provided."); + // Perform the purchase. } + function withdraw() public { + if (msg.sender != owner) + revert Unauthorized(); - function withdraw() external { - uint256 amount = balances[msg.sender]; - (bool success, ) = msg.sender.call.value(amount)(""); - require(success); - balances[msg.sender] = 0; + payable(msg.sender).transfer(address(this).balance); } } ``` -Pour permettre à un utilisateur de retirer l'ETH qu'il a précédemment stocké dans le contrat, cette fonction : +### 3. Tester les contrats intelligents et vérifier la justesse du code {#test-smart-contracts-and-verify-code-correctness} + +L'immuabilité du code exécuté dans la [Machine Virtuelle Ethereum](/developers/docs/evm/) signifie que les contrats intelligents exigent un plus haut niveau d'évaluation de la qualité pendant la phase de développement. Tester votre contrat de manière intensive et l'observer pour déceler tout résultat inattendu améliorera considérablement la sécurité et protégera vos utilisateurs sur le long terme. + +La méthode habituelle est d'écrire de petits tests unitaires à l'aide de données fictives que le contrat devrait recevoir de la part des utilisateurs. [Le test unitaire](/developers/docs/smart-contracts/testing/#unit-testing) est bon pour tester la fonctionnalité de certaines fonctions et pour s'assurer qu'un contrat intelligent fonctionne comme prévu. + +Malheureusement, les tests unitaires sont peu efficaces pour améliorer la sécurité des contrats intelligents lorsqu'ils sont utilisés isolément. Un test unitaire peut prouver qu'une fonction s'exécute correctement pour les données simulées, mais les tests unitaires sont seulement aussi efficaces que les tests écrits. Il est donc difficile de détecter les cas et les vulnérabilités marginaux manqués qui pourraient nuire à la sécurité de votre contrat intelligent. + +Une meilleure approche est de combiner les tests unitaires avec des tests fondés sur les propriétés effectués en utilisant [l'analyse statique et dynamique](/developers/docs/smart-contracts/testing/#static-dynamic-analysis). L'analyse statique repose sur des représentations de bas niveau, tels que [des graphiques de flux de contrôle](https://en.wikipedia.org/wiki/Control-flow_graph) et [des arbres de syntaxe abstraite](https://deepsource.io/glossary/ast/) pour analyser les états de programme et les chemins d'exécution accessibles. D'autre part, les techniques d'analyse dynamique, telles que le fuzzing, exécutent du code de contrat avec des valeurs d'entrées aléatoires pour détecter les opérations qui violent les propriétés de sécurité. + +[La vérification formelle](/developers/docs/smart-contracts/formal-verification) est une autre technique de vérification des propriétés de sécurité dans les contrats intelligents. Contrairement aux tests réguliers, la vérification formelle peut prouver de façon concluante l'absence d'erreurs dans un contrat intelligent. Ceci est réalisé en créant une spécification formelle qui permet de saisir les propriétés de sécurité désirées et de prouver qu'un modèle formel des contrats adhère à cette spécification. + +### 4. Demander une revue indépendante de votre code {#get-independent-code-reviews} + +Après avoir testé votre contrat, il est bon de demander à d'autres de vérifier le code source pour tout problème de sécurité. Les tests ne décèleront pas toutes les failles d'un contrat intelligent, mais obtenir un examen indépendant augmente la possibilité de détecter les vulnérabilités. + +#### Audits {#audits} + +Demander un audit des contrats intelligents est une façon de procéder à un examen indépendant du code. Les vérificateurs jouent un rôle important en veillant à ce que les contrats intelligents soient sécurisés et exempts de défauts de qualité et d'erreurs de conception. + +Cela dit, évitez de considérer les audits comme un remède miracle. Les audits de contrats intelligents ne saisiront pas chaque bogue et sont principalement conçus pour fournir une série de revues complémentaires, qui peut aider à détecter les problèmes qui auront échappé aux développeurs lors du développement et du test initial. Suivez également [les bonnes pratiques pour travailler avec les auditeurs](https://twitter.com/tinchoabbate/status/1400170232904400897), comme documenter le code correctement et ajouter de commentaires en ligne, pour maximiser les avantages d'un audit des contrats intelligents. + +#### Chasse à la prime {#bug-bounties} + +La mise en place d'un programme de prime de bogues est une autre approche pour implémenter des examens de code externes. Une prime de bogue est une récompense financière donnée aux individus (généralement des hackers whitehat) qui découvrent des vulnérabilités dans une application. + +Lorsqu'elle est utilisée correctement, la primes de bogues incitent les membres de la communauté hacker à inspecter votre code pour trouver des défauts critiques. Un exemple réel est le « bogue d'argent infini » qui aurait permis à un attaquant de créer un nombre illimité d'Ether sur [Optimisme](https://www.optimism.io/), un protocole [Couche 2](https://ethereum.org/en/layer-2/) fonctionnant sur Ethereum. Heureusement, un hacker whitehat [a découvert le défaut](https://www.saurik.com/optimism.html) et l'a notifié à l'équipe, [gagnant une grosse prime ce faisant](https://cryptoslate.com/critical-bug-in-ethereum-l2-optimism-2m-bounty-paid/). + +Une stratégie utile est de définir le paiement d'un programme de prime de bogues proportionnellement au montant des fonds mis en jeu. Décrit comme la «[mise à l'échelle de la prime de bogue](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7)», cette approche fournit des incitations financières pour les individus à divulguer de manière responsable des vulnérabilités au lieu de les exploiter. + +### 5. Suivre les bonnes pratiques lors du développement de contrats intelligents {#follow-smart-contract-development-best-practices} + +L’existence d’audits et de primes de bogue n'exclut pas votre responsabilité d’écrire un code de haute qualité. Une bonne sécurité du contrat intelligent commence en suivant des processus de conception et de développement adéquats : + +- Stocker tout le code dans un système de contrôle de version, tel que git + +- Effectuer toutes les modifications de code via des pulls requests + +- Assurez-vous que les pulls requests ont au moins un réviseur indépendant — si vous travaillez en solo sur un projet, envisagez de trouver d'autres développeurs et d'échanger mutuellement vos avis sur le code + +- Utilisez un [environnement de développement](/developers/docs/frameworks/) pour tester, compiler, déployer des contrats intelligents + +- Exécutez votre code sur des outils d'analyse de code basiques, tels que Mythril et Slither. Idéalement, vous devriez le faire avant de fusionner chaque pull request et comparer les différences de sortie + +- Assurez-vous que votre code est compilé sans erreurs, et que le compilateur Solidity n'émet aucun avertissement + +- Documentez correctement votre code (en utilisant [NatSpec](https://solidity.readthedocs.io/en/develop/natspec-format.html)) et décrivez les détails sur l'architecture du contrat dans un langage facile à comprendre. Cela facilitera l'audit et l'examen de votre code pour les autres. + +### 6. Mettre en œuvre des plans de relance robustes en cas de catastrophe {#implement-disaster-recovery-plans} + +La conception de contrôles d'accès sécurisés, la mise en œuvre de modificateurs de fonction et d'autres suggestions peuvent améliorer la sécurité des contrats intelligents, mais elles ne peuvent pas exclure la possibilité d'exploits malveillants. Pour élaborer des contrats intelligents sécurisés, il faut se « préparer à l'échec » et disposer d'un plan de repli pour répondre efficacement aux attaques. Un plan de reprise après sinistre adéquat intègre tout ou partie des éléments suivants : + +#### Mise à niveau du contrat {#contract-upgrades} + +Bien que les contrats intelligents Ethereum soient immuables par défaut, il est possible d'obtenir un certain degré de mutabilité en utilisant des modèles de mise à niveau. La mise à niveau des contrats est nécessaire dans les cas où une faille critique rend votre ancien contrat inutilisable et où le déploiement d'une nouvelle logique est l'option la plus réalisable. -1. lit le solde de l'utilisateur ; -2. lui envoie le solde en ETH ; -3. réinitialise le solde à 0, de sorte que l'utilisateur ne puisse pas retirer le solde de nouveau. +Les mécanismes de mise à niveau des contrats fonctionnent différemment, mais le « modèle proxy » est l'une des approches les plus populaires pour la mise à niveau des contrats intelligents. Les modèles de proxy divisent l'état et la logique d'une application entre _deux_ contrats. Le premier contrat (appelé « contrat mandataire ») stocke les variables d'état (par exemple, les soldes des utilisateurs), tandis que le second contrat (appelé « contrat logique ») contient le code d'exécution des fonctions du contrat. -Si elle est appelée à partir d'un compte normal (comme celui de votre propre compte MetaMask), elle fonctionne comme prévu : msg.sender.call.value() envoie simplement l'ETH vers votre compte. Toutefois, les contrats intelligents peuvent également effectuer des appels. Si un contrat personnalisé et malveillant appelle la fonction `withdraw()`, msg.sender.call.value() n'enverra pas le montant d'ETH (via `amount`), mais appellera aussi implicitement le contrat pour commencer à exécuter du code. Imaginez le contrat malveillant suivant : +Les comptes interagissent avec le contrat du mandataire, qui envoie tous les appels de fonction au contrat logique en utilisant l'appel de bas niveau [`delegatecall()`](https://docs.soliditylang.org/en/v0.8.16/introduction-to-smart-contracts.html?highlight=delegatecall#delegatecall-callcode-and-libraries). Contrairement à un appel de message ordinaire, `delegatecall()` garantit que le code exécuté à l'adresse du contrat logique est exécuté dans le contexte du contrat appelant. Cela signifie que le contrat logique écrira toujours dans le stockage du proxy (au lieu de son propre stockage) et les valeurs originales des `msg.sender` et `msg.value` sont préservées. + +La délégation des appels au contrat logique nécessite de stocker son adresse dans le stockage du contrat de procuration. Par conséquent, la mise à niveau de la logique du contrat consiste simplement à déployer un autre contrat logique et à stocker la nouvelle adresse dans le contrat de procuration. Comme les appels ultérieurs au contrat de procuration sont automatiquement acheminés vers le nouveau contrat logique, vous aurez « mis à niveau » le contrat sans modifier réellement le code. + +[En savoir plus sur la mise à niveau des contrats](/developers/docs/smart-contracts/upgrading/). + +#### Arrêts d'urgence {#emergency-stops} + +Comme nous l'avons mentionné, les audits et les tests approfondis ne peuvent pas découvrir tous les bugs d'un contrat intelligent. Si une vulnérabilité apparaît dans votre code après le déploiement, il est impossible de la corriger puisque vous ne pouvez pas modifier le code exécuté à l'adresse du contrat. De plus, les mécanismes de mise à niveau ( par exemple, les modèles de procuration) peuvent prendre du temps à se mettre en œuvre (ils nécessitent souvent l'approbation de différentes parties), ce qui ne fait que donner plus de temps aux attaquants pour causer plus de dommages. + +L'option nucléaire consiste à mettre en œuvre une fonction « d'arrêt d'urgence » qui bloque les appels aux fonctions vulnérables dans un contrat. Les arrêts d'urgence comprennent généralement les composants suivants : + +1. Une variable booléenne globale indiquant si le contrat intelligent est dans un état arrêté ou non. Cette variable est définie à `false` lors de la mise en place du contrat, mais elle deviendra `vraie` une fois le contrat arrêté. + +2. Les fonctions qui font référence à la variable booléenne dans leur exécution. Ces fonctions sont accessibles lorsque le contrat intelligent n'est pas arrêté, et deviennent inaccessibles lorsque la fonction d'arrêt d'urgence est déclenchée. + +3. Une entité qui a accès à la fonction d'arrêt d'urgence, qui définit la variable booléenne à `true`. Pour éviter les actions malveillantes, les appels à cette fonction peuvent être limités à une adresse de confiance (par exemple, le propriétaire du contrat). + +Une fois que le contrat a activé l'arrêt d'urgence, certaines fonctions ne seront pas appelables. Pour ce faire, les fonctions de sélection sont enveloppées dans un modificateur qui fait référence à la variable globale. Voici [un exemple](https://github.com/fravoll/solidity-patterns/blob/master/EmergencyStop/EmergencyStop.sol) décrivant une implémentation de ce modèle dans les contrats : ```solidity -contract Attacker { - function beginAttack() external payable { - Victim(VICTIM_ADDRESS).deposit.value(1 ether)(); - Victim(VICTIM_ADDRESS).withdraw(); +// Ce code n'a pas fait l'objet d'un audit professionnel et ne fait aucune promesse quant à sa sécurité ou son exactitude. Utilisez-le à vos risques et périls. + +contract EmergencyStop { + + bool isStopped = false; + + modifier stoppedInEmergency { + require(!isStopped); + _; } - function() external payable { - if (gasleft() > 40000) { - Victim(VICTIM_ADDRESS).withdraw(); - } + modifier onlyWhenStopped { + require(isStopped); + _; + } + + modifier onlyAuthorized { + // Check for authorization of msg.sender here + _; + } + + function stopContract() public onlyAuthorized { + isStopped = true; + } + + function resumeContract() public onlyAuthorized { + isStopped = false; + } + + function deposit() public payable stoppedInEmergency { + // Deposit logic happening here + } + + function emergencyWithdraw() public onlyWhenStopped { + // Emergency withdraw happening here } } ``` -Appeler Attacker.beginAttack() démarrera un cycle qui ressemble à quelque chose comme ça : +Cet exemple montre les caractéristiques de base des arrêts d'urgence : -``` -0.) Attacker's EOA calls Attacker.beginAttack() with 1 ETH -0.) Attacker.beginAttack() deposits 1 ETH into Victim - - 1.) Attacker -> Victim.withdraw() - 1.) Victim reads balances[msg.sender] - 1.) Victim sends ETH to Attacker (which executes default function) - 2.) Attacker -> Victim.withdraw() - 2.) Victim reads balances[msg.sender] - 2.) Victim sends ETH to Attacker (which executes default function) - 3.) Attacker -> Victim.withdraw() - 3.) Victim reads balances[msg.sender] - 3.) Victim sends ETH to Attacker (which executes default function) - 4.) Attacker no longer has enough gas, returns without calling again - 3.) balances[msg.sender] = 0; - 2.) balances[msg.sender] = 0; (it was already 0) - 1.) balances[msg.sender] = 0; (it was already 0) -``` +- `isStopped` est un booléen qui évalue à `false` en début et à `true` lorsque le contrat entre en mode d'urgence. -Appeller Attacker.beginAttack avec 1 ETH génère une nouvelle attaque par réentrance contre la victime, retirant plus d'ETH qu'il n'en a été fourni (prélevé sur les soldes des autres utilisateurs, entraînant une sous-garantie du contrat de la victime) +- Les modificateurs de fonction `onlyWhenStopped` et `stoppedInEmergency` vérifient la variable `isStopped`. `stoppedInEmergency` est utilisé pour piloter des fonctions qui doivent être inaccessibles lorsque le contrat est vulnérable (par exemple : `deposit()`). Les appels à ces fonctions seront tout simplement annulés. -### Comment gérer la réentrance (de la mauvaise façon) {#how-to-deal-with-re-entrancy-the-wrong-way} +`onlyWhenStopped` est utilisé pour des fonctions qui doivent être appelables pendant une urgence (par exemple, `emergencyWithdraw()`). De telles fonctions peuvent aider à résoudre la situation, d’où leur exclusion de la liste des « fonctions restreintes ». -On pourrait envisager de contrecarrer la réentrance en empêchant simplement les contrats intelligents d'interagir avec votre code. Vous recherchez stackoverflow, vous trouvez cet extrait de code avec des tonnes de votes positifs : +L'utilisation d'une fonctionnalité d'arrêt d'urgence constitue un palliatif efficace pour faire face aux vulnérabilités graves de votre contrat intelligent. Cependant, les utilisateurs doivent faire confiance aux développeurs pour qu'ils ne l'activent pas pour des raisons intéressées. À cette fin, décentraliser le contrôle de l'arrêt d'urgence soit en le soumettant à un mécanisme de vote en chaîne, un timelock, ou à l'approbation d'un portefeuille multisig sont des solutions possibles. -```solidity -function isContract(address addr) internal returns (bool) { - uint size; - assembly { size := extcodesize(addr) } - return size > 0; -} -``` +#### Suivi des événements {#event-monitoring} + +[Les événements](https://docs.soliditylang.org/en/v0.8.15/contracts.html#events) vous permettent de suivre les appels vers les fonctions des contrats intelligents et de surveiller les changements apportés aux variables d'état. Il est idéal de programmer votre contrat intelligent pour qu'il émette un événement chaque fois qu'une partie prend une mesure critique en matière de sécurité (par exemple, retirer des fonds). + +Le log des événements et leur surveillance hors chaîne fournissent un aperçu des opérations contractuelles et aide à la découverte plus rapide des actions malveillantes. Cela signifie que votre équipe peut réagir plus rapidement aux hacks et prendre des mesures pour atténuer l'impact sur les utilisateurs, tels que suspendre les fonctions ou effectuer une mise à niveau. + +Vous pouvez également opter pour un outil de surveillance en vente libre qui transmet automatiquement les alertes lorsque quelqu'un interagit avec vos contrats. Ces outils vous permettent de créer des alertes personnalisées basées sur différents déclencheurs, comme le volume de la transaction, la fréquence des appels de fonctions, ou les fonctions spécifiques impliquées. Par exemple, vous pouvez programmer une alerte qui arrive lorsque le montant retiré en une seule opération dépasse un seuil particulier. + +### 7. Concevoir des systèmes de gouvernance sécurisés {#design-secure-governance-systems} + +Vous voudrez peut-être décentraliser votre application en transférant le contrôle des contrats intelligents de base aux membres de la communauté. Dans ce cas, le système de contrats intelligents comprendra un module de gouvernance, un mécanisme qui permet aux membres de la communauté d'approuver des actions administratives via un système de gouvernance en chaîne. Par exemple, une proposition de mise à niveau d'un contrat de procuration vers une nouvelle implémentation peut être votée par les détenteurs de jetons. + +Une gouvernance décentralisée peut être bénéfique, en particulier parce qu'elle aligne les intérêts des développeurs et des utilisateurs finaux. Néanmoins, les mécanismes de gouvernance des contrats intelligents peuvent introduire de nouveaux risques s'ils sont mal mis en œuvre. Un scénario plausible est si un attaquant acquiert un énorme pouvoir de vote (mesuré en nombre de jetons conservés) en prenant un [crédit flash](/defi/#flash-loans) et en poussant une proposition malveillante. + +Une façon de prévenir les problèmes liés à la gouvernance sur la chaîne est d'utiliser [un timelock](https://blog.openzeppelin.com/protect-your-users-with-smart-contract-timelocks/). Un timelock empêche un contrat intelligent d'exécuter certaines actions jusqu'à ce qu'un certain temps passe. D'autres stratégies incluent l'assignation d'une « pondération de vote » à chaque jeton en fonction de la durée d'enfermement de chaque jeton, ou mesurant le pouvoir de vote d'une adresse à une période historique (par exemple, 2-3 blocs dans le passé) au lieu du bloc actuel. Les deux méthodes réduisent la possibilité d’amasser rapidement le pouvoir de vote pour basculer sur les votes en chaîne. + +En savoir plus sur [la conception de systèmes de gouvernance sécurisée](https://blog.openzeppelin.com/smart-contract-security-guidelines-4-strategies-for-safer-governance-systems/) et [de mécanismes de vote différents dans les DAO](https://hackernoon.com/governance-is-the-holy-grail-for-daos). + +### 8. Réduire la complexité du code à un minimum {#reduce-code-complexity} + +Les développeurs de logiciels traditionnels sont familiers avec le principe KISS (« keep it simple, stupid ») qui recommande de ne pas introduire de complexité inutile dans la conception de logiciels. Cela fait suite à la pensée de longue date selon laquelle « les systèmes complexes échouent de manière complexe » et sont plus susceptibles d’être confrontés à des erreurs coûteuses. -Cela semble sensé : les contrats ont du code, si l'appelant a du code, cele ne l'autorise pas à déposer. Tentons de l'ajouter : +Garder les choses simples est particulièrement important lors de la rédaction de contrats intelligents, étant donné que les contrats intelligents contrôlent potentiellement de grandes quantités de valeur. Une astuce pour atteindre la simplicité lors de l'écriture de contrats intelligents est de réutiliser des bibliothèques existantes, telles que les [contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/4.x/), lorsque cela est possible. Parce que ces bibliothèques ont été largement vérifiées et testées par les développeurs, leur utilisation réduit les chances d'introduire des bogues en écrivant de nouvelles fonctionnalités à partir de zéro. + +Un autre conseil commun est d'écrire de petites fonctions et de garder les contrats modulaires en divisant la logique commerciale entre plusieurs contrats. Non seulement l'écriture de code plus simple réduit la surface d'attaque dans un contrat intelligent, mais il est également plus facile de raisonner sur la justesse du système global et de détecter les éventuelles erreurs de conception plus tôt. + +### 9. Protéger contre les vulnérabilités communes des contrats intelligents {#mitigate-common-smart-contract-vulnerabilities} + +#### Réentrance {#reentrancy} + +L’EVM ne permet pas la simultanéité, ce qui signifie que deux contrats impliqués dans un appel de message ne peuvent pas être exécutés simultanément. Un appel externe met en pause l'exécution et la mémoire du contrat d'appel jusqu'à ce que l'appel revienne, à partir duquel l'exécution du point se déroule normalement. Ce processus peut être décrit formellement comme le transfert du [flux de contrôle](https://www.computerhope.com/jargon/c/contflow.htm) vers un autre contrat. + +Bien que la plupart du temps inoffensifs, le transfert de flux de contrôle vers des contrats non approuvés peut causer des problèmes, tels que la réentrance. Une attaque par réentrance survient lorsqu'un contrat malveillant rappelle un contrat vulnérable avant que l'invocation de la fonction d'origine ne soit terminée. Ce type d'attaque est mieux expliqué avec un exemple. + +Considérez un simple contrat intelligent (« Victim ») qui permet à quiconque de déposer et de retirer de l'Ether : ```solidity -// CE CONTRAT A UNE VULNÉRABILITÉ INTENTIONNELLE, NE PAS COPIER -contract ContractCheckVictim { - mapping (address => uint256) public balances; +// This contract is vulnerable. Do not use in production - function isContract(address addr) internal returns (bool) { - uint size; - assembly { size := extcodesize(addr) } - return size > 0; - } +contract Victim { + mapping (address => uint256) public balances; function deposit() external payable { - require(!isContract(msg.sender)); // <- NEW LINE balances[msg.sender] += msg.value; } @@ -155,39 +253,61 @@ contract ContractCheckVictim { } ``` -Maintenant pour déposer de l'ETH, vous ne devez pas avoir de code de contrat intelligent à votre adresse. Ceci est néanmoins facilement surmonté avec le contrat d'attaquant suivant : +Ce contrat expose une fonction `withdraw()` pour permettre aux utilisateurs de retirer de l'ETH précédemment déposé dans le contrat. Lors du traitement d'un retrait, le contrat effectue les opérations suivantes : -```solidity -contract ContractCheckAttacker { - constructor() public payable { - ContractCheckVictim(VICTIM_ADDRESS).deposit(1 ether); // <- New line - } +1. Vérifie le solde ETH de l'utilisateur +2. Envoie des fonds à l'adresse d'appel +3. Réinitialise son solde à 0, empêchant les retraits supplémentaires de l'utilisateur + +La fonction `withdraw()` dans le contrat `Victim` suit un modèle « checks-interactions-effects ». Il _vérifie_ si les conditions nécessaires à l'exécution sont satisfaites (c.-à-d. l'utilisateur a un solde ETH positif) et effectue l'interaction \__ en envoyant l'ETH à l'adresse de l'appelant, avant d'appliquer les \_effets_ de la transaction (c.-à-d., réduisant le solde de l’utilisateur). + +Si la fonction `withdraw()` est appelée depuis un compte externe (Externally Orné Account, dit EOA), la fonction s'exécute comme attendu : `msg.sender.call.value()` envoie l'ETH à l'appelant. Cependant, si `msg.sender` est un compte de contrat intelligent qui appelle `withdraw()`, l'envoie de fonds en utilisant `msg.sender.call.value()` déclenchera également le code stocké à cette adresse pour l'exécuter. +Imaginez qu'il s'agisse du code déployé à l'adresse du contrat: + +```solidity + contract Attacker { function beginAttack() external payable { - ContractCheckVictim(VICTIM_ADDRESS).withdraw(); + Victim(victim_address).deposit.value(1 ether)(); + Victim(victim_address).withdraw(); } function() external payable { if (gasleft() > 40000) { - Victim(VICTIM_ADDRESS).withdraw(); + Victim(victim_address).withdraw(); } - } + } } ``` -Alors que la première attaque était une attaque sur la logique du contrat, il s'agit maintenant d'une attaque sur le comportement de déploiement du contrat Ethereum. Pendant la construction, un contrat n'a pas encore renvoyé le code à déployer à son adresse, mais conserve le contrôle complet de l'EVM DURANT ce processus. +Ce contrat est conçu pour faire trois choses : + +1. Accepter un dépôt depuis un autre compte (probablement l’EOA de l’attaquant) +2. Dépose 1 ETH dans le contrat Victim +3. Retirer 1 ETH stocké dans le contrat intelligent -Il est techniquement possible d'empêcher les contrats intelligents d'appeler votre code, en utilisant cette ligne : +Il n'y a rien de mal ici, excepté que l'`Attacker` a une autre fonction qui appelle `withdraw()` dans `Victim` à nouveau si le gaz restant du `msg.sender.call.value` entrant est supérieur à 40 000. Cela donne à l'`Attacker` la possibilité de rentrer `Victim` et de retirer plus de fonds _avant que_ la première invocation de `withdraw` soit terminée. Le cycle ressemble à ceci: ```solidity -require(tx.origin == msg.sender) +- L'EOA de l'attaquant appelle `Attacker.beginAttack()` avec 1 ETH +- `Attaquant.beginAttack()` dépose 1 ETH dans `Victim` +- `Attacker` appelle `withdraw() dans `Victim` +- `Victim` vérifie le solde de `Attacker` (1 ETH) +- `Victim` envoie 1 ETH à `Attacker` (qui déclenche la fonction par défaut) +- `Attacker` appelle `Victim.withdraw()` à nouveau (notez que `Victim` n'a pas réduit le solde de `Attacker` à partir du premier retrait) +- `Victim` vérifie le solde de `Attacker` (qui est toujours 1 ETH car il n'a pas appliqué les effets du premier appel) +- `Victim` envoie 1 ETH à `Attacker` (qui déclenche la fonction par défaut et permet à `Attacker` de réintroduire la fonction `withdraw`) +- Le processus se répète jusqu'à ce que `Attacker` soit épuisé, à quel point `msg.sender.call.value` retourne sans déclencher de retraits supplémentaires +- `Victim` applique enfin les résultats de la première transaction (et de celles subséquentes) à son état, donc le solde de `Attacker` est fixé à 0 ``` -Cependant, ce n'est toujours pas une bonne solution. L'un des aspects les plus passionnants d'Ethereum est sa composabilité : ses contrats intelligents s'intègrent et se construisent les uns avec les autres. En utilisant la ligne ci-dessus, vous limitez l'utilité de votre projet. +Le résumé est que, comme le solde de l'appelant n'est pas défini à 0 jusqu'à ce que l'exécution de la fonction soit terminée, les invocations suivantes réussiront et permettront à l'appelant de retirer son solde plusieurs fois. Ce type d'attaque peut être utilisé pour drainer un contrat intelligent de ses fonds, comme ce qui s'est passé dans le hack [DAO 2016](https://www.coindesk.com/learn/2016/06/25/understanding-the-dao-attack/). Les attaques par réentrance sont toujours un problème critique pour les contrats intelligents aujourd'hui, comme le montre [les listes publiques des exploits de réentrance](https://github.com/pcaversaccio/reentrancy-attacks). + +##### Comment empêcher les attaques par réentrance -### Comment gérer la réentrance (de la bonne façon) {#how-to-deal-with-re-entrancy-the-right-way} +Une approche pour traiter la réentrance est de suivre le [modèle de vérifications-effets-interactions](https://docs.soliditylang.org/en/develop/security-considerations.html#use-the-checks-effects-interactions-pattern). Ce modèle ordonne l'exécution de fonctions d'une manière que le code qui effectue les vérifications nécessaires avant de progresser avec l'exécution arrive en premier, suivi du code qui manipule l'état du contrat, avec du code qui interagit avec d'autres contrats ou EOA arrivant en dernier. -En changeant simplement l'ordre de la mise à jour de stockage et de l'appel externe, nous empêchons la condition de réentrance qui a permis l'attaque. Un rappel vers un retrait, bien que possible, ne profitera pas à l'attaquant puisque le stockage des `soldes` sera déjà défini à 0. +Le modèle de vérifications-effets-interactions est utilisé dans une version révisée du contrat `Victim` affichée ci-dessous : ```solidity contract NoLongerAVictim { @@ -200,128 +320,234 @@ contract NoLongerAVictim { } ``` -Le code ci-dessus suit le modèle de conception "Checks-Effects-Interactions", qui aide à se protéger contre la réentrance. En savoir plus sur le modèle [Checks-Effects-Interactions](https://fravoll.github.io/solidity-patterns/checks_effects_interactions.html) +Ce contrat effectue un _check_ sur le solde de l'utilisateur, applique les _effects_ de la fonction `withdraw()` (en réinitialisant le solde de l'utilisateur à 0), et procède à l’exécution de l'_interaction_ (envoi de l’ETH à l’adresse de l’utilisateur). Cela garantit que le contrat met à jour son stockage avant l’appel externe, éliminant ainsi la condition de réentrance qui a permis la première attaque. Le contrat `Attacker` pourrait toujours être rappelé dans `NoLongerAVictim`, mais depuis que `balances[msg.sender]` a été réglé à 0, les retraits supplémentaires lanceront une erreur. -### Comment gérer la réentrance (l'option nucléaire) {#how-to-deal-with-re-entrancy-the-nuclear-option} +Une autre option est d'utiliser un verrou d'exclusion mutuelle (communément décrit comme un « mutex ») qui verrouille une partie de l'état d'un contrat jusqu'à ce qu'une invocation de fonction soit terminée. Ceci est implémenté en utilisant une variable booléenne qui est définie à `true` avant que la fonction ne s'exécute et retourne à `false` après que l'invocation ait été faite. Comme on le voit dans l'exemple ci-dessous, l'utilisation d'un mutex protège une fonction contre les appels récursifs alors que l'invocation originale est toujours en cours de traitement, empêchant ainsi efficacement la réentrance. -Chaque fois que vous envoyez de l'ETH à une adresse non fiable ou que vous interagissez avec un contrat inconnu (comme appeler le "`transfer()`" d'une adresse de jeton fournie par l'utilisateur), vous vous exposez à un risque de réentrance. **En concevant des contrats qui n'envoient pas d'ETH et n'appellent pas de contrats non fiables, vous empêchez la possiblité de réentrance !** +```solidity +pragma solidity ^0.7.0; -## Autres types d'attaques {#more-attack-types} +contract MutexPattern { + bool locked = false; + mapping(address => uint256) public balances; -Les types d'attaque ci-dessus couvrent les problèmes de codage de contrats intelligents (réentrance) et les anomalies Ethereum (exécution de code dans les constructeurs de contrats, avant que le code ne soit disponible à l'adresse du contrat). Il existe beaucoup, beaucoup d'autres types d'attaque à connaître, y compris : + modifier noReentrancy() { + require(!locked, "Blocked from reentrancy."); + locked = true; + _; + locked = false; + } + // This function is protected by a mutex, so reentrant calls from within `msg.sender.call` cannot call `withdraw` again. + // The `return` statement evaluates to `true` but still evaluates the `locked = false` statement in the modifier + function withdraw(uint _amount) public payable noReentrancy returns(bool) { + require(balances[msg.sender] >= _amount, "No balance to withdraw."); -- Front running -- Rejet d'envoi d'ETH -- Dépassement/sous-flux d'entier + balances[msg.sender] -= _amount; + bool (success, ) = msg.sender.call{value: _amount}(""); + require(success); + + return true; + } +} +``` -Complément d'information: +Vous pouvez également utiliser un système de [« pull payments »](https://docs.openzeppelin.com/contracts/4.x/api/security#PullPayment) qui demande aux utilisateurs de retirer des fonds des contrats intelligents, au lieu d'un système de paiement « push payments » qui envoie des fonds à des comptes. Cela élimine la possibilité de déclencher par inadvertance du code à des adresses inconnues (et peut également prévenir certaines attaques par déni de service). -- [Consensys Smart Contract Known Attacks](https://consensys.github.io/smart-contract-best-practices/attacks/) - Une explication très lisible des vulnérabilités les plus importantes, avec un exemple de code pour la plupart. -- [Registre SWC](https://swcregistry.io/docs/SWC-128) - Liste conservée des CWE qui s'appliquent à Ethereum et aux contrats intelligents +#### Soupassements et dépassements d'entier {#integer-underflows-and-overflows} -## Outils de sécurité {#security-tools} +Un dépassement d'entier se produit lorsque les résultats d'une opération arithmétique tombent en dehors de la plage de valeurs acceptable, le faisant passer à la valeur représentable la plus basse. Par exemple, un `uint8` ne peut stocker que des valeurs allant jusqu'à 2^8-1=255. Les opérations arithmétiques qui aboutissent à des valeurs supérieures à `255` dépasseront et réinitialiseront `uint` à `0`, similaire à la façon dont l'odomètre sur une voiture se réinitialise à 0 une fois qu'il atteint le kilométrage maximum (999999). -Bien qu'il n'y ait pas de substitut à la compréhension des bases de sécurité d'Ethereum et à l'engagement d'un expert pour revoir votre code, il existe de nombreux outils disponibles pour aider à mettre en évidence les problèmes potentiels présents dans votre code. +Les soupassements d'entier se produisent pour des raisons similaires : les résultats d'une opération arithmétique sont inférieurs à la fourchette acceptable. Disons que vous avez essayé de diminuer `0` dans un `uint8`, le résultat ne ferait que passer à la valeur représentative maximale (`255`). -### Sécurité des contrats intelligents {#smart-contract-security} +Les dépassements d'entier et les soupassements peuvent entraîner des changements inattendus dans les variables d'état d'un contrat et entraîner une exécution non planifiée. Voici un exemple montrant comment un attaquant peut exploiter un dépassement arithmétique dans un contrat intelligent pour effectuer une opération invalide : -**Slither -** **_Infrastructure d'analyse statique Solidity rédigé en Python 3_** +``` +pragma solidity ^0.7.6; + +// Ce contrat est conçu pour servir de coffre temporel. +// L'utilisateur peut déposer dans ce contrat mais ne peut pas se retirer pendant au moins une semaine. +// L'utilisateur peut également prolonger le temps d'attente au-delà de la période d'attente de 1 semaine. -- [GitHub](https://github.com/crytic/slither) +/* +1. Déployer TimeLock +2. Déployer l'Attaque avec l'adresse de TimeLock +3. Appeler Attaque.attack en envoyant 1 éther. Vous pourrez immédiatement + retirer votre éther. -**MythX -** **_API d'analyse de sécurité pour les contrats intelligents Ethereum_** +Que s'est-il passé ? +L'attaque a causé un dépassement de TimeLock.lockTime et a pu entraîner un retrait +avant la période d'attente d'une semaine. +*/ -- [mythx.io](https://mythx.io/) -- [Documentation](https://docs.mythx.io/) +contract TimeLock { + mapping(address => uint) public balances; + mapping(address => uint) public lockTime; -**Mythril -** **_Outil d'analyse de sécurité pour le bytecode de l'EVM_** + function deposit() external payable { + balances[msg.sender] += msg.value; + lockTime[msg.sender] = block.timestamp + 1 weeks; + } -- [mythril](https://github.com/ConsenSys/mythril) -- [Documentation](https://mythril-classic.readthedocs.io/en/master/about.html) + function increaseLockTime(uint _secondsToIncrease) public { + lockTime[msg.sender] += _secondsToIncrease; + } -**Manticore -** **_Interface en ligne de commande qui utilise un outil d'exécution symbolique sur les contrats intelligents et les fichiers binaires_** + function withdraw() public { + require(balances[msg.sender] > 0, "Insufficient funds"); + require(block.timestamp > lockTime[msg.sender], "Lock time not expired"); -- [GitHub](https://github.com/trailofbits/manticore) -- [Documentation](https://github.com/trailofbits/manticore/wiki) + uint amount = balances[msg.sender]; + balances[msg.sender] = 0; -**Securify -** **_Scanner de sécurité pour les contrats intelligents Ethereum_** + (bool sent, ) = msg.sender.call{value: amount}(""); + require(sent, "Failed to send Ether"); + } +} -- [securify.chainsecurity.com](https://securify.chainsecurity.com/) -- [Discord](https://discordapp.com/invite/nN77ckb) +contract Attack { + TimeLock timeLock; -**ERC20 Verifier -** **_Outil utilisé pour vérifier qu'un contrat est conforme à la norme ERC20_** + constructor(TimeLock _timeLock) { + timeLock = TimeLock(_timeLock); + } -- [erc20-verifier.openzeppelin.com](https://erc20-verifier.openzeppelin.com) -- [Forum](https://forum.openzeppelin.com/t/online-erc20-contract-verifier/1575) + fallback() external payable {} + + function attack() public payable { + timeLock.deposit{value: msg.value}(); + /* + if t = current lock time then we need to find x such that + x + t = 2**256 = 0 + so x = -t + 2**256 = type(uint).max + 1 + so x = type(uint).max + 1 - t + */ + timeLock.increaseLockTime( + type(uint).max + 1 - timeLock.lockTime(address(this)) + ); + timeLock.withdraw(); + } +} +``` -### Vérification formelle {#formal-verification} +##### Comment éviter les soupassements et dépassements d'entier -**Informations sur la vérification formelle** +Depuis la version 0.8.0, le compilateur Solidity rejette le code qui entraîne des soupassements et dépassements d'entier. Cependant, les contrats compilés avec une version inférieure du compilateur devraient soit effectuer des vérifications sur des fonctions impliquant des opérations arithmétiques soit utiliser une bibliothèque (par ex., [SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math)) qui vérifie le soupassement/dépassement. -- [Fonctionnement de la vérification formelle des contacts intelligents](https://runtimeverification.com/blog/how-formal-verification-of-smart-contracts-works/) _- Brian Marick, 20 juillet 2018_ -- [Comment la vérification formelle peut garantir des contrats intelligents sans faille](https://media.consensys.net/how-formal-verification-can-ensure-flawless-smart-contracts-cbda8ad99bd1) _29 - Bernard Mueller, janvier 2018_ +#### Manipulation Oracle {#oracle-manipulation} -### Utilisation d'outils {#using-tools} +[Les Oracles](/developers/docs/oracles/) sourcent des informations hors chaîne et les envoient en chaîne pour les contrats intelligents à utiliser. Avec des oracles, vous pouvez concevoir des contrats intelligents qui interagissent avec des systèmes hors chaîne, tels que les marchés de capitaux, en élargissant considérablement leur application. -Deux des outils les plus populaires pour l'analyse de sécurité des contrats intelligents sont : +Mais si l'oracle est corrompu et envoie des informations incorrectes en chaîne, les contrats intelligents s'exécuteront sur la base d'entrées erronées, ce qui peut causer des problèmes. C'est la base du « problème de l'oracle », qui concerne la tâche de s'assurer que les informations provenant d'un oracle de la blockchain sont exactes, à jour et en temps opportun. -- [Slither](https://github.com/crytic/slither) par [Trail of Bits](https://www.trailofbits.com/) (version hébergée : [Crytic](https://crytic.io/)) -- [Mythril](https://github.com/ConsenSys/mythril) par [ConsenSys](https://consensys.net/) (version hébergée : [MythX](https://mythx.io/)) +Une préoccupation liée à la sécurité consiste à utiliser un oracle en chaîne, tel qu'un échange décentralisé, pour obtenir le prix au comptant d'un actif. Les plateformes de prêt dans l'industrie [de la finance décentralisée (DeFi)](/defi/) le font souvent pour déterminer la valeur de la garantie d'un utilisateur pour déterminer le montant qu'il peut emprunter. -Tous deux sont des outils utiles qui analysent votre code et signalent les problèmes. Chacun possède une version hébergée par [commercial], mais est également disponible gratuitement pour fonctionner localement. Voici un bref exemple de la façon d'exécuter Slither, disponible dans une image Docker pratique `trailofbits/eth-security-toolbox`. Vous devrez [installer Node.js](https://nodejs.org/) si vous ne l’avez pas déjà fait. +Les prix des DEX sont souvent exacts, en grande partie en raison du rétablissement de la parité sur les marchés. Cependant, ils sont ouverts à la manipulation, en particulier si l'oracle sur la chaîne calcule les prix des actifs en fonction des modèles de négociation historiques (comme c'est généralement le cas). -```bash -$ mkdir test-slither -$ curl https://gist.githubusercontent.com/epheph/460e6ff4f02c4ac582794a41e1f103bf/raw/9e761af793d4414c39370f063a46a3f71686b579/gistfile1.txt > bad-contract.sol -$ docker run -v `pwd`:/share -it --rm trailofbits/eth-security-toolbox -docker$ cd /share -docker$ solc-select 0.5.11 -docker$ slither bad-contract.sol -``` +Par exemple, un attaquant pourrait artificiellement pomper le prix au comptant d'un actif en souscrivant un prêt flash juste avant d'interagir avec votre contrat de prêt. Interroger le DEX pour le prix de l’actif reviendrait à une valeur plus élevée que la normale (en raison de la forte demande de transfert de « l'ordre d’achat » de l’attaquant pour l’actif), leur permettant d'emprunter plus qu'ils ne le devraient. De telles « attaques de prêts flash » ont été utilisées pour exploiter la dépendance à l'égard de prix oracles parmi les applications DeFi, coûtant des millions de protocoles en fonds perdus. -génèrera cette sortie : - -```bash -ethsec@1435b241ca60:/share$ slither bad-contract.sol -INFO:Detectors: -Reentrancy in Victim.withdraw() (bad-contract.sol#11-16): - External calls: - - (success) = msg.sender.call.value(amount)() (bad-contract.sol#13) - State variables written after the call(s): - - balances[msg.sender] = 0 (bad-contract.sol#15) -Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities -INFO:Detectors: -Low level call in Victim.withdraw() (bad-contract.sol#11-16): - - (success) = msg.sender.call.value(amount)() (bad-contract.sol#13) -Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls -INFO:Slither:bad-contract.sol analyzed (1 contracts with 46 detectors), 2 result(s) found -INFO:Slither:Use https://crytic.io/ to get access to additional detectors and GitHub integration -``` +##### Comment éviter la manipulation d'oracle -Slither a identifié le potentiel de réentrance, ainsi que les lignes clés où le problème pourrait se produire, et nous donne un lien pour plus de détails sur le problème ici : +Le minimum requis pour éviter la manipulation d'oracle est d'utiliser un réseau oracle décentralisé qui interroge des informations provenant de sources multiples pour éviter des points de défaillance uniques. Dans la plupart des cas, les oracles décentralisés ont des incitations cryptoéconomiques intégrées pour encourager les noeuds d'oracle à signaler des informations correctes, les rendant plus sûres que les oracles centralisés. -> Référence : https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities +Si vous comptez interroger un oracle sur le prix des actifs, envisagez d'utiliser un mécanisme qui implémente un prix moyen pondéré (« Time Weighted Average Price », dit TWAP). Un [oracle TWAP](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) interroge le prix d'un actif à deux points différents dans le temps (que vous pouvez modifier) et calcule le prix au comptant en fonction de la moyenne obtenue. Le choix de périodes plus longues protège votre protocole contre la manipulation des prix car les larges ordres exécutés récemment ne peuvent pas affecter les prix des actifs. -Ceci vous permet de connaître rapidement les problèmes potentiels dans votre code. Comme tous les outils de test automatisés, Slither n'est pas parfait, et peut signaler trop d'erreurs dans le rapport. Il peut avertir d'une éventuelle réentrance, même si aucune vulnérabilité exploitable n'existe. Souvent, l'examen des DIFFERENCES entre les changements de code répertoriées dans le rapport Slither est extrêmement utile, car il aide à découvrir les vulnérabilités introduites beaucoup plus tôt que si vous attendez la fin de votre projet. +## Ressources de sécurité de contrats intelligents pour les développeurs {#smart-contract-security-resources-for-developers} -## Complément d'information {#further-reading} +### Outils pour analyser les contrats intelligents et vérifier la justesse du code {#code-analysis-tools} -**Guides des bonnes pratiques de sécurité pour les contrats intelligents** +- **[Outils de test et bibliothèques](/developers/docs/smart-contracts/testing/#testing-tools-and-libraries)** - _Collection d'outils et de bibliothèques standards pour effectuer des tests unitaires, des analyses statiques et des analyses dynamiques des contrats intelligents._ -- [consensys.github.io/smart-contract-best-practices/](https://consensys.github.io/smart-contract-best-practices/) -- [GitHub](https://github.com/ConsenSys/smart-contract-best-practices/) -- [Collection agrégée de recommandations de sécurité et de bonnes pratiques](https://github.com/guylando/KnowledgeLists/blob/master/EthereumSmartContracts.md) +- **[Outils de vérification formels](/developers/docs/smart-contracts/formal-verification/#formal-verification-tools)** - _Outils de vérification de l'exactitude fonctionnelle dans les contrats intelligents et de vérification des invariants._ -**Standard de vérification de la sécurité des contrats intelligents (SCSVS)** +- **[Services d'audit de contrats intelligents](/developers/docs/smart-contracts/testing/#smart-contract-auditing-services)** - _Liste des organisations fournissant des services d'audit de contrats intelligents pour les projets de développement d'Ethereum._ -- [securing.github.io/SCSVS/](https://securing.github.io/SCSVS/) +- **[Plateformes de récompenses de bugs](https://ethereum.org/en/developers/docs/smart-contracts/testing/#bug-bounty-platforms)** - _Plateformes pour coordonner les récompenses de bugs et récompensant la divulgation responsable de vulnérabilités critiques dans les contrats intelligents._ -_Une ressource communautaire vous a aidé ? Modifiez cette page et ajoutez-la !_ +- **[Fork Checker](https://forkchecker.hashex.org/)** - _ : Il s'agit d'un outil gratuit en ligne pour la vérification de toutes les informations disponibles concernant un contrat issu du fork._ -## Tutoriels connexes {#related-tutorials} +- **[ABI Encoder](https://abi.hashex.org/)** - _ : Il s'agit d'un service gratuit en ligne pour l'encodage des fonctions de contrat Solidity et de vos arguments de constructeur._ + +### Outils de surveillance des contrats intelligents {#smart-contract-monitoring-tools} + +- **[Sentinelles de défenseur OpenZeppelin](https://docs.openzeppelin.com/defender/sentinel)** - _Un outil pour surveiller et répondre automatiquement aux événements, fonctions et paramètres de transaction sur vos contrats intelligents._ + +- **[Alerte en temps réel Tenderly](https://tenderly.co/alerting/)** - _Un outil pour recevoir des notifications en temps réel lorsque des événements inhabituels ou inattendus se produisent sur vos contrats intelligents ou portefeuilles._ + +### Outils pour une administration sécurisée des contrats intelligents {#smart-contract-administration-tools} + +- **[OpenZeppelin Defender Admin](https://docs.openzeppelin.com/defender/admin)** - _Interface pour gérer l'administration des contrats intelligents, y compris les contrôles d'accès, les mises à jour et la pause._ + +- **[Safe](https://safe.global/)** - _Portefeuille à contrat intelligent fonctionnant sur Ethereum qui exige qu'un nombre minimum de personnes approuvent une transaction avant qu'elle ne puisse avoir lieu (M-of-N)._ + +- **[Contrats OpenZeppelin](https://docs.openzeppelin.com/contracts/4.x/)** - _Bibliothèques de contrats pour l'implémentation de fonctions administratives, y compris la propriété contractuelle, les mises à niveau, les contrôles d'accès, la gouvernance, les possibilités de pause, et plus encore._ + +### Services d'audit pour contrat intelligent {#smart-contract-auditing-services} + +- **[Diligence ConsenSys](https://consensys.net/diligence/)** - _Service d'audit de contrat intelligent pour aider les projets à travers l'écosystème de la blockchain à s'assurer que leurs protocoles sont prêts à être lancés et construits pour protéger les utilisateurs._ + +- **[CertiK](https://www.certik.com/)** - _société de sécurité blockchain pionnière dans l'utilisation d'une technologie de vérification formelle de pointe sur les contrats intelligents et les réseaux blockchain._ + +- **[Trail of Bits](https://www.trailofbits.com/)** - _Entreprise de cybersécurité qui combine la recherche de sécurité avec une mentalité d'attaquant pour réduire le risque et fortifier le code._ + +- **[PeckShield](https://peckshield.com/)** - _Société de sécurité blockchain offrant des produits et des services pour la sécurité, la confidentialité et la convivialité de l'ensemble de l'écosystème blockchain._ + +- **[QuantStamp](https://quantstamp.com/)** - _Service d'audit facilitant l'adoption courante de la technologie blockchain par les services de sécurité et d'évaluation des risques._ + +- **[OpenZeppelin](https://www.openzeppelin.com/security-audits)** - _Société de sécurité de contrat intelligent fournissant des audits de sécurité pour les systèmes distribués._ + +- **[Vérification de l'exécution](https://runtimeverification.com/)** - _Entreprise de sécurité spécialisée dans la modélisation et la vérification formelles des contrats intelligents._ + +- **[Hacken](https://hacken.io)** - _Auditeur de cybersécurité Web3 apportant une approche à 360° à la sécurité de la blockchain._ + +- **[Nethermind](https://nethermind.io/smart-contracts-audits)** - _Des services offrant des audits Cairo et Solidity, utilisés comme garantie pour assurer l'intégrité des contrats intelligents et la sécurité des utilisateurs dans les écosystèmes Ethereum et Starknet._ + +- **[HashEx](https://hashex.org/)** - _Les rapports d'audit présentés par HashEx relatifs à la blockchain et aux contrats intelligents, visent à garantir la sécurité des cryptomonnaies, fournissant des services tels que le développement des contrats intelligents, le test de pénétration, ou le conseil blockchain._ + +### Plateformes de récompense de bug {#bug-bounty-platforms} + +- **[Immunefi](https://immunefi.com/)** - _Plateforme de récompense de bug pour les contrats intelligents et les projets DeFi, où les chercheurs en sécurité examinent le code, révèlent les vulnérabilités, sont payés et rendent les crypto-monnaies plus sûres._ + +- **[HackerOne](https://www.hackerone.com/)** - _Coordination de vulnérabilité et plateforme de récompense de bogue qui relie les entreprises aux testeurs de pénétration et aux chercheurs en cybersécurité._ + +- **[HackenProof](https://hackenproof.com/)** - _Plateforme de récompense de bogue pour les projets de cryptomonnaies (DeFi, contrats intelligents, portefeuilles, CEX et bien plus encore), où les professionnels de la sécurité fournissent des services de triage et les chercheurs sont payés pour des rapports de bogues pertinents et vérifiés._ + +### Publications de vulnérabilités connues de contrats intelligents et d'exploitations {#common-smart-contract-vulnerabilities-and-exploits} + +- **[ConsenSys : Attaques connues sur les contrats intelligents](https://consensys.github.io/smart-contract-best-practices/attacks/)** - _Explication conviviale pour le débutant des vulnérabilités contractuelles les plus significatives, avec le code d'échantillon pour la plupart des cas._ + +- **[Registre SWC](https://swcregistry.io/)** - _Liste organisée d'éléments d'énumération des faiblesses communes (« Common Weakness Enumeration », dit CWE) qui s'appliquent aux contrats intelligents Ethereum._ + +- **[Rekt](https://rekt.news/)** - _Publication mise à jour régulière de hacks et d'exploits de cryptomonnaies haut de gamme, ainsi que de rapports détaillés post-mortem._ + +### Défis pour l'apprentissage de la sécurité des contrats intelligents {#challenges-for-learning-smart-contract-security} + +- **[Awesome BlockSec CTF](https://github.com/blockthreat/blocksec-ctfs)** - _Liste organisée des wargames de sécurité de la blockchain, des défis, des concours [Capture The Flag](https://www.webopedia.com/definitions/ctf-event/amp/) concours et des rédactions de solutions._ + +- **[Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz/)** - _Wargame pour apprendre la sécurité offensive des contrats intelligents DeFi et développer des compétences en matière de chasse aux bogues et d'audit de sécurité._ + +- **[Ethernaut](https://ethernaut.openzeppelin.com/)** - _Wargame basé sur Web3/Solidity où chaque niveau est un contrat intelligent qui doit être « hacké »._ + +### Meilleures pratiques pour sécuriser les contrats intelligents {#smart-contract-security-best-practices} + +- **[Consensys : Meilleures pratiques en termes de sécurité pour les contrats intelligents Ethereum](https://consensys.github.io/smart-contract-best-practices/)** - _Liste complète de lignes directrices pour sécuriser les contrats intelligents Ethereum._ + +- **[Nascent : Boîte à outils de sécurité simple](https://github.com/nascentxyz/simple-security-toolkit)** - _Collection de guides pratiques axés sur la sécurité et de listes de contrôle pour le développement de contrats intelligents._ + +- **[Modèles Solidity](https://fravoll.github.io/solidity-patterns/)** -> _Compilation utile de pratiques sécurisées et de meilleures pratiques pour le langage de programmation des contrats intelligents Solidity._ + +- **[Docs Solidity : considérations en matière de sécurité](https://docs.soliditylang.org/en/v0.8.16/security-considerations.html)** - _Directives pour l'écriture de contrats intelligents sécurisés avec Solidity._ + +- **[Norme de vérification de la sécurité des contrats intelligents](https://github.com/securing/SCSVS)** - _Liste de contrôle de quatorze parties créée pour standardiser la sécurité des contrats intelligents pour les développeurs, architectes, réviseurs de sécurité et fournisseurs._ + +### Tutoriels sur la sécurité des contrats intelligents {#tutorials-on-smart-contract-security} + +- [Comment écrire des contrats intelligents sécurisés](/developers/tutorials/secure-development-workflow/) + +- [Comment utiliser Slither pour trouver des bugs de contrat intelligent](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) -- [Flux de développement sécurisé](/developers/tutorials/secure-development-workflow/) -- [Comment utiliser Slither pour trouver les bogues dans les contrats intelligents](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) - [Comment utiliser Manticore pour trouver les bogues dans les contrats intelligents](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) -- [Consignes de sécurité](/developers/tutorials/smart-contract-security-guidelines/) -- [Sécurité des jetons](/developers/tutorials/token-integration-checklist/) + +- [Directives de sécurité pour les contrats intelligents](/developers/tutorials/smart-contract-security-guidelines/) + +- [Comment intégrer en toute sécurité votre contrat de jetons avec des jetons arbitraires](/developers/tutorials/token-integration-checklist/) diff --git a/src/content/translations/fr/developers/docs/storage/index.md b/src/content/translations/fr/developers/docs/storage/index.md index 2fecae6b20b..dc598eaaff2 100644 --- a/src/content/translations/fr/developers/docs/storage/index.md +++ b/src/content/translations/fr/developers/docs/storage/index.md @@ -1,10 +1,10 @@ --- title: Stockage décentralisé -description: Présentation du stockage décentralisé et des outils disponibles à intégrer dans une DApp +description: Présentation du stockage décentralisé et des outils disponibles à intégrer dans une dApp. lang: fr --- -Contrairement à un serveur centralisé exploité par une unique organisation ou une entreprise, les systèmes de stockage décentralisé se composent d'un réseau de pair à pair d'opérateurs-utilisateurs qui détiennent une partie de l'ensemble des données, créant ainsi un système de partage de fichiers résiliant. Cela peut être via une application basée sur la blockchain ou bien sur n'importe quel réseau basé sur le principe du pair à pair. +Contrairement à un serveur centralisé exploité par une entreprise ou organisation unique, les systèmes de stockage décentralisé se composent d'un réseau de pair à pair d'opérateurs-utilisateurs qui détiennent une partie de l'ensemble des données, créant ainsi un système de partage de fichiers résiliant. Cela peut être via une application basée sur la blockchain ou bien sur n'importe quel réseau basé sur le principe du pair à pair. Ethereum lui-même peut être utilisé comme un système de stockage décentralisé, c'est d'ailleurs déjà le cas concernant le stockage de code compris dans tous les contrats intelligent. Cependant, lorsqu'il s'agit de grandes quantités de données, Ethereum n'a été conçu pour cela. La chaîne ne cesse de croître, mais au moment d'écrire ces lignes, la chaîne Ethereum est d'environ 500 Go à 1 To ([selon le client](https://etherscan.io/chartsync/chaindefault)), et chaque nœud du réseau doit être en mesure de stocker toutes les données. Si la chaîne devait s'étendre à de grandes quantités de données (disons 5 To par exemple), il serait impossible pour tous les nœuds de continuer à fonctionner. En outre, le coût du déploiement d'une telle quantité de données sur le réseau principal serait prohibitif en raison des frais de [gaz](/developers/docs/gas). @@ -17,7 +17,7 @@ En se penchant sur la question des options de stockage décentralisé (dStorage) - Décentralisé - Consensus -## Mécanisme de persistance / structure d'incitation {#persistence-mechanism} +## Mécanisme de persistance / structure incitative {#persistence-mechanism} ### Orientation blockchain {#blockchain-based} @@ -27,7 +27,7 @@ Ce processus est connu sous le nom de : persistance **basée sur la blockchain** Le problème avec la persistance basée sur la blockchain est que la chaîne pourrait devenir beaucoup trop grande pour entretenir et stocker toutes les données (ex. [de nombreuses sources](https://healthit.com.au/how-big-is-the-internet-and-how-do-we-measure-it/) estiment que l'Internet nécessite plus de 40 Zetabytes de capacité de stockage). -La blockchain doit également avoir une certaine structure incitative. Pour la persistance basée sur la blockchain, il y a un paiement effectué au mineur. Lorsque les données sont ajoutées à la chaîne, les nœuds sont payés pour y ajouter les données. +La blockchain doit également avoir une certaine structure incitative. Pour la persistance basée sur la blockchain, il y a un paiement effectué au validateur. Les validateurs sont payés pour ajouter les données lorsqu'elles sont ajoutées à la chaine. Plateformes avec persistance basée sur la blockchain : @@ -46,6 +46,9 @@ Les plateformes avec persistance basée sur contrat : - [Skynet](https://siasky.net/) - [Storj](https://storj.io/) - [0Chain](https://0chain.net/) +- [Réseau Crust](https://crust.network) +- [Swarm](https://www.ethswarm.org/) +- [4EVERLAND](https://www.4everland.org/) ### Autres considérations {#additional-consideration} @@ -55,6 +58,11 @@ IPFS est un système distribué pour stocker et accéder aux fichiers, sites Web - [Pinata](https://www.pinata.cloud/) _(service d'épinglage IPFS)_ - [web3.storage](https://web3.storage/) _(service d'épinglage IPFS/Filecoin)_ - [Infura](https://infura.io/product/ipfs) _(service d'épinglage IPFS)_ +- [IPFS Scan](https://ipfs-scan.io) _(explorateur IPFS pinning)_ +- [4EVERLAND](https://www.4everland.org/)_ (service d'épinglage IPFS) _ +- [Filebase](https://filebase.com) _(Service d'épinglage IPFS)_ + +SWARM est une technologie décentralisée de stockage et de distribution de données avec un système incitatif de stockage et un prix de location de stockage oracle. ## Conservation des données {#data-retention} @@ -70,6 +78,8 @@ Types de dStorage avec mécanisme de challenge : - Skynet - Arweave - Filecoin +- Réseau Crust +- 4EVERLAND ### Décentralisation {#decentrality} @@ -83,22 +93,24 @@ Outils décentralisés sans KYC : - Filecoin - IPFS - Ethereum +- Réseau Crust +- 4EVERLAND ### Consensus {#consensus} -La plupart de ces outils ont leur propre version de [mécanisme de consensus](/developers/docs/consensus-mechanisms/) mais généralement ils sont basés soit sur une [**Preuve de travail (PoW)**](/developers/docs/consensus-mechanisms/pow/) ou une [**Preuve d'enjeu (PoS)**](/developers/docs/consensus-mechanisms/pos/). +La plupart de ces outils ont leur propre version de [mécanisme de consensus](/developers/docs/consensus-mechanisms/) mais généralement ils sont basés soit sur une [**Preuve de travail (PoW)**](/developers/docs/consensus-mechanisms/pow/) soit sur une [**Preuve d'enjeu (PoS)**](/developers/docs/consensus-mechanisms/pos/). -Basé PoW : +Preuve de travail (PoW) : - Skynet - Arweave -- Ethereum -Basé PoS : +Preuve d'enjeu (PoS) : -- [La chaîne phare](/roadmap/beacon-chain/) +- Ethereum - Filecoin - 0Chain +- Réseau Crust ## Outils connexes {#related-tools} @@ -112,6 +124,7 @@ Basé PoS : - [Storj.io](https://storj.io/) - [Documentation](https://docs.storj.io/) +- [GitHub](https://github.com/storj/storj) **Skynet - _Skynet est une chaîne PoW décentralisée dédiée à un Web décentralisé._** @@ -131,12 +144,18 @@ Basé PoS : - [Documentation](https://docs.arweave.org/info/) - [Arweave](https://github.com/ArweaveTeam/arweave/) -**0chain - _0Chain est une plateforme dStorage basée Preuve d'enjeu avec des fragments et des blobbers._** +**0chain - _0Chain est une plateforme dStorage basée sur la Preuve d'enjeu avec des fragments et des blobbers._** - [0Chain.net](https://0chain.net/) - [Documentation](https://docs.0chain.net/0chain/) - [GitHub](https://github.com/0chain/) +**Réseau Crust - _Crust est une plateforme dStorage basée sur IPFS_** + +- [Crust.network](https://crust.network) +- [Documentation](https://wiki.crust.network) +- [Github](https://github.com/crustio) + **Swarm - _Plateforme de stockage distribuée et service de distribution de contenu pour la pile web3 Ethereum_** - [EthSwarm.org](https://www.ethswarm.org/) @@ -161,12 +180,24 @@ Basé PoS : - [Documentation](https://developers.ceramic.network/learn/welcome/) - [GitHub](https://github.com/ceramicnetwork/js-ceramic/) -**Filebase - _La première plate-forme de stockage d'objet compatible S3 qui vous permet de stocker des données sur plusieurs réseaux de stockage décentralisés, y compris IPFS, Sia, Skynet et Storj._** +**File base - _Stockage décentralisé compatible S3 et service d'épinglage IPFS géo-redondant. Tous les fichiers téléchargés sur IPFS via Filebase sont automatiquement épinglés à l'infrastructure Filebase avec une réplication 3x à travers le monde._** - [Filebase.com](https://filebase.com/) - [Documentation](https://docs.filebase.com/) - [GitHub](https://github.com/filebase) +**4EVERLAND - _Une plateforme de calcul cloud Web 3 qui intègre les capacités de stockage, de calcul et de réseautage de base, est compatible S3 et fournit un stockage de données synchronisé sur les réseaux de stockage décentralisés tels que IPFS et Arweave._** + +- [4everland.org](https://www.4everland.org/) +- [Documentation](https://docs.4everland.org/) +- [GitHub](https://github.com/4everland) + +**Kaleido - _Une plateforme blockchain-as-a-service avec un bouton clic IPFS Nodes_** + +- [Kaleido](https://kaleido.io/) +- [Documentation](https://docs.kaleido.io/kaleido-services/ipfs/) +- [GitHub](https://github.com/kaleido-io) + ## Complément d'information {#further-reading} - [Qu'est-ce qu'un stockage décentralisé ?](https://coinmarketcap.com/alexandria/article/what-is-decentralized-storage-a-deep-dive-by-filecoin) - _CoinMarketCap_ diff --git a/src/content/translations/it/bridges/index.md b/src/content/translations/it/bridges/index.md index 0ccfca2cf30..c012e52508d 100644 --- a/src/content/translations/it/bridges/index.md +++ b/src/content/translations/it/bridges/index.md @@ -35,6 +35,8 @@ I ponti consentono: - agli utenti di accedere a nuove piattaforme e sfruttare i benefici di catene differenti. - agli sviluppatori da ecosistemi della blockchain differenti, di collaborare e creare nuove piattaforme per gli utenti. +[Come collegare i token al livello 2](/guides/how-to-use-a-bridge/) + ## Casi d'uso dei ponti {#bridge-use-cases} diff --git a/src/content/translations/it/community/grants/index.md b/src/content/translations/it/community/grants/index.md index 9ac65feabde..77f6117deb6 100644 --- a/src/content/translations/it/community/grants/index.md +++ b/src/content/translations/it/community/grants/index.md @@ -20,7 +20,8 @@ Questi programmi supportano il grande ecosistema di Ethereum offrendo sovvenzion - [Moloch DAO](https://www.molochdao.com/) - _Privacy, ridimensionamento di livello 2, sicurezza del client e molto altro_ - [Sovvenzioni aperte](https://opengrants.com/explore) - [DAO Grants](https://docs.google.com/spreadsheets/d/1XHc-p_MHNRdjacc8uOEjtPoWL86olP4GyxAJOFO0zxY/edit#gid=0) - _Foglio di calcolo di Google delle organizzazioni che offrono sovvenzioni_ -- [Sovvenzioni accademiche](https://esp.ethereum.foundation/academic-grants-2023) - _Sovvenzioni per sostenere il lavoro accademico correlato a Ethereum_ +- [Crunchbase per sovvenzioni Web3](https://www.cryptoneur.xyz/web3-grants) - _Filtra e cerca sovvenzioni per categorie, casi d'uso, importi e altro. Contribuisci ad aiutare gli altri a trovare la giusta sovvenzione._ +- [Sovvenzioni accademiche](https://esp.ethereum.foundation/academic-grants) - _Sovvenzioni per sostenere il lavoro accademico correlato a Ethereum_ ## Programmi per progetti specifici {#project-specific} @@ -30,12 +31,13 @@ Questi progetti hanno creato le proprie sovvenzioni per progetti volti a svilupp - [Balancer](https://balancergrants.notion.site/Balancer-Community-Grants-23e562c5bc4347cd8304637bff0058e6) – _[Balancer](https://balancer.fi/) ecosystem fund_ - [Chainlink Grants Program](https://chain.link/community/grants) - _Sovvenzioni per la comunity di [Chainlink](https://chain.link/)_ - [Compound Grants Program](https://compoundgrants.org/) – _Ecosistema finanziario [Compound](https://compound.finance/)_ +- [Decentraland Grants Program](https://governance.decentraland.org/grants/) - _Metaverso DAO di [Decentraland](https://decentraland.org/)_ - [Lido Ecosystem Grants Organisation (LEGO)](https://lego.lido.fi/) – _Ecosistema finanziario di [Lido](https://lido.fi/)_ -- [Programma di MetaMask](https://metamaskgrants.org/): _DAO di sovvenzioni operata dai dipendenti di [MetaMask](https://metamask.io/)_ -- [Programma di Sovvenzioni di mStable](https://docs.mstable.org/advanced/grants-program) - _Community di [mStable](https://mstable.org/)_ -- [The Graph](https://airtable.com/shrdfvnFvVch3IOVm) – _Ecosistema di [The Graph](https://thegraph.com/)_ -- [Programma di Sovvenzioni UMA](https://grants.umaproject.org/): _Supporto per sviluppatori dell'[UMA](https://umaproject.org/)_ -- [Programma di Sovvenzioni di Uniswap](https://www.unigrants.org/) – _Community di [Uniswap](https://uniswap.org/)_ +- [MetaMask Program](https://metamaskgrants.org/): _DAO di sovvenzioni operata dai dipendenti di [MetaMask](https://metamask.io/)_ +- [mStable Grants Program](https://docs.mstable.org/advanced/grants-program) - _Community [mStable](https://mstable.org/)_ +- [The Graph](https://airtable.com/shrdfvnFvVch3IOVm) – _Ecosistema [The Graph](https://thegraph.com/)_ +- [UMA Grants Program](https://grants.umaproject.org/): _Supporto per sviluppatori [UMA](https://umaproject.org/)_ +- [Uniswap Grants Program](https://www.unigrants.org/) – _Community [Uniswap](https://uniswap.org/)_ - [Sovvenzioni Web3](https://web3grants.net): _Un elenco completo di programmi di sovvenzione relativi a web3/cripto_ ## Finanziamento quadratico {#quadratic-funding} diff --git a/src/content/translations/it/community/support/index.md b/src/content/translations/it/community/support/index.md index 6d18d844cb2..96e96738c49 100644 --- a/src/content/translations/it/community/support/index.md +++ b/src/content/translations/it/community/support/index.md @@ -38,10 +38,11 @@ Cerchi un portafoglio Ethereum? [Esplora il nostro elenco completo di portafogli La costruzione può essere difficile. Ecco alcuni spazi focalizzati sullo sviluppo, con sviluppatori Ethereum esperti che sono felici di aiutarti. +- [Alchemy University](https://university.alchemy.com/#starter_code) - [CryptoDevs discord](https://discord.gg/Z9TA39m8Yu) - [StackExchange Ethereum](https://ethereum.stackexchange.com/) - [StackOverflow](https://stackoverflow.com/questions/tagged/web3) -- [Università Web3](https://www.web3.university/) +- [Web3 University](https://www.web3.university/) Puoi anche trovare la documentazione e le guide di sviluppo nella nostra sezione [risorse per sviluppatore Ethereum](/developers/). diff --git a/src/content/translations/it/dao/index.md b/src/content/translations/it/dao/index.md index 46a0333a79a..393a40b4a09 100644 --- a/src/content/translations/it/dao/index.md +++ b/src/content/translations/it/dao/index.md @@ -1,145 +1,145 @@ --- title: Organizzazioni autonome decentralizzate (DAO) -description: Una panoramica dei DAO su Ethereum +description: Una panoramica delle DAO su Ethereum lang: it template: use-cases emoji: ":handshake:" sidebarDepth: 3 image: ../../../../assets/use-cases/dao-2.png -alt: Rappresentazione di una votazione DAO su una proposta. -summaryPoint1: Comunità di proprietà dei membri senza leadership centralizzata. +alt: Una rappresentazione di una votazone DAO su una proposta. +summaryPoint1: Comunità possedute dai membri, prive di leadership centralizzata. summaryPoint2: Un modo sicuro per collaborare con sconosciuti su Internet. summaryPoint3: Un luogo sicuro per impegnare fondi in una causa specifica. --- ## Cosa sono le DAO? {#what-are-daos} -Con il termine DAO si intende una organizzazione di proprietà collettiva governata da blockchain che lavora per realizzare una missione condivisa. +Una DAO è un'organizzazione posseduta collettivamente e governata dalla blockchain, che opera per realizzare una missione condivisa. -Le DAO permettono di lavorare con persone con la stessa mentalità provenienti da tutto il mondo doversi fidare di un leader benevolo per gestire i fondi o le operazioni. Non esiste alcun CEO che possa spendere i fondi secondo i propri capricci o un CFO che possa manipolare i libri contabili. Invece, le regole basate sulla blockchain integrate nel codice definiscono il funzionamento dell'organizzazione e come vengono spesi i fondi. +Le DAO ci consentono di lavorare con persone dalla stessa mentalità in tutto il mondo, senza doversi fidare di un capo benevolo, per la gestione di fondi od operazioni. Non esiste alcun CEO che possa spendere fondi secondo i propri capricci, o CFO che possa manipolare i libri contabili. Invece, le regole basate sulla blockchain, integrate nel codice, definiscono il funzionamento dell'organizzazione e come sono spesi i fondi. -Contengono al loro interno un patrimonio a cui nessuno ha l'autorità di accedere senza l'approvazione del gruppo. Le decisioni sono governate da proposte e votazioni per garantire che tutti nell'organizzazione abbiano voce in capitolo, e tutto si verifica in modo trasparente sulla catena. +Contengono tesoriere integrate, a cui nessuno è autorizzato ad accedere, senza l'approvazione del gruppo. Le decisioni sono governate da proposte e votazioni, per assicurarsi che tutti nell'organizzazione abbiano voce in capitolo, e che tutto si verifichi in modo trasparente sulla catena. -## Perché abbiamo bisogno delle DAO? {#why-dao} +## Perché necessitiamo delle DAO? {#why-dao} -Per avviare un'organizzazione con altre persone quando sono in ballo finanziamenti e denaro occorre riporre molta fiducia nei propri compagni di avventura. Ma è difficile fidarsi di qualcuno con cui hai interagito solo tramite Internet. Con le DAO non occorre fidarsi di nessun altro nel gruppo, bensì solamente del codice DAO, che è al 100% trasparente e verificabile da chiunque. +Avviare un'organizzazione con altre persone, quando finanziamenti e denaro sono in ballo, richiede molta fiducia nelle persone con cui collabori. Ma fidarsi di qualcuno con cui ha interagito soltanto su Internet è difficile. Con le DAO non è necessario fidarsi di nessun altro nel gruppo, bensì, solamente del codice della DAO, trasparente al 100% e verificabile da chiunque. -Ciò apre molte opportunità di cooperazione e coordinamento a livello globale. +Ciò apre molte nuove opportunità di cooperazione e coordinmento globale. ### Un confronto {#dao-comparison} -| DAO | Organizzazione tradizionale | -| --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | -| Di solito orizzontale e completamente democratizzata. | Di solito gerarchica. | -| Votazione richiesta dai membri per l'implementazione di eventuali modifiche. | A seconda della struttura, le modifiche possono essere richieste da una sola parte oppure sottoposte a votazione. | -| Conteggio dei voti e implementazione automatica del risultato senza intermediari. | Se la votazione è consentita, i voti sono conteggiati internamente e l'esito della votazione deve essere gestito manualmente. | -| I servizi offerti vengono gestiti automaticamente in modo decentralizzato (ad esempio distribuzione di fondi filantropici). | Richiede manipolazione umana o automazione controllata centralmente, suscettibile di manipolazione. | -| Tutte le attività sono trasparenti e completamente pubbliche. | L'attività è tipicamente privata e limitata al pubblico. | +| DAO | Un'organizzazione tradizionale | +| ---------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | +| Soltamente orizzontale e interamente democraticizzata. | Solitamente gerarchica. | +| Votazioni richieste dai membri per l'implementazione di qualsiasi modifica. | A seconda della struttura, le modifiche possono essere richieste da una sola parte, altrmenti potrebbe esser richiesta una votazione. | +| Conteggio dei voti e implementazione automatica del risultato, senza intermediari. | Se la votazione è consentita, i voti sono conteggiati internamente e il risultato dev'essere gestito manualmente. | +| I servizi offerti sono automaticamente gestiti in modo decentralizzato (ad esempio, la distribuzione di fondi filantropici). | Richiede la gestione umana, o l'automazione controllata centralmente, suscettibile alla manipolazione. | +| Tutte le attività sono trasparenti e interamente pubbliche. | L'attività è tipicamente privata e limitata al pubblico. | ### Esempi di DAO {#dao-examples} Per aiutarti a comprendere meglio, ecco alcuni esempi di come potresti utilizzare una DAO: -- Beneficenza – potresti accettare donazioni da chiunque nel mondo e votare su quali cause finanziare. -- Proprietà collettiva – potresti acquistare beni fisici o digitali e i membri possono votare su come usarli. -- Iniziative e sovvenzioni – potresti creare un fondo di rischio che riunisce capitale di investimento e vota sulle iniziative da finanziare. Il denaro rimborsato potrebbe essere successivamente ridistribuito tra i membri del DAO. +- Beneficenza: potresti accettare donazioni da chiunque nel mondo e votare su quali cause finanziare. +- Proprietà collettiva: potresti acquistare beni fisici o digitali e, i membri, potrebbero votare su come utilizzarli. +- Iniziative e sovvenzioni: potresti creare un fondo di rischio che raggruppi il capitale di investimento e votare sulle iniziative da finanziare. Il denaro rimborsato potrebbe essere in seguito redistribuito tra i membri della DAO. -## Come funziona la DAO? {#how-daos-work} +## Come funzionano le DAO? {#how-daos-work} -La spina dorsale di una DAO è il suo contratto intelligente, che definisce le regole dell'organizzazione e detiene il patrimonio del gruppo. Una volta che il contratto è attivo su Ethereum, nessuno può modificare le regole se non tramite voto. Nessuno può fare qualcosa che non sia previsto dalle regole e dalla logica del codice. E poiché anche il patrimonio è definito dal contratto intelligente, ciò significa che nessuno può spendere il denaro senza l'approvazione del gruppo. Questo significa che le DAO non hanno bisogno di un'autorità centrale. Al contrario, il gruppo prende le decisioni collettivamente e i pagamenti sono autorizzati automaticamente quando le proposte sono approvate dal voto. +La spina dorsale di una DAO è il suo contratto intelligente, che definisce le regole dell'organizzazione e ne detiene il patrimonio. Una volta che il contratto è attivo su Ethereum, nessuno può modificarne le regole, tranne tramite voto. Se qualcuno prova a fare qualcosa che non sia previsto dalle regole e dalla logica nel codice, fallirà. E poiché anche il patrimonio è definito dal contratto intelligente, ciò significa che nessuno può spendere denaro senza l'approvazione del gruppo. Ciò significa che le DAO non necessitano di un'autorità centrale. Invece, il gruppo prende le decisioni collettivamente, e i pagamenti sono autorizzati automaticamente all'approvazione del voto. -Ciò è possibile perché i contratti intelligenti sono a prova di manomissione, una volta che sono attivi su Ethereum. Non è possibile modificare il codice (le regole della DAO) senza che gli altri lo notino, perché tutto è pubblico. +Ciò è possibile perché i contratti intelligenti sono a prova di manomissione, una volta attivi su Ethereum. Non puoi semplicemente modificare il codice (le regole delle DAO), senza che gli altri lo notino, poiché tutto è pubblico. Di più sui contratti intelligenti -## Ethereum e DAO {#ethereum-and-daos} +## Ethereum e le DAO {#ethereum-and-daos} -Ethereum è la base perfetta per le DAO per una serie di motivi: +Ethereum è la base perfetta per le DAO per numerose motivazioni: -- Il consenso di Ethereum è sufficientemente distribuito e affermato affinché le organizzazioni possano fidarsi della rete. -- Il codice del contratto intelligente non è modificabile una volta attivato, nemmeno dai suoi proprietari. Ciò permette alla DAO di funzionare secondo le regole con cui è stata programmata. -- I contratti intelligenti possono inviare/ricevere fondi. In caso contrario occorrerebbe un intermediario fidato per gestire i fondi del gruppo. -- La community di Ethereum si è dimostrata più collaborativa che competitiva, consentendo l'emergere rapido di migliori pratiche e sistemi di supporto. +- Il consenso di Ethereum è sufficientemente distribuito e affermato affinché le organizzazioni si fidino della rete. +- Il codice del contratto intelligente non è modificabile una volta attivato, nemmeno dai suoi proprietari. Ciò consente alla DAO di operare secondo le regole con cui è stata programmata. +- I contratti intelligenti possono inviare e ricevere fondi. Altrimenti, necessiteresti di un intermediario fidato per gestire i fondi del gruppo. +- La community di Ethereum si è dimostrata più collaborativa che competitiva, consentendo la rapida emersione delle migliori pratiche e dei sistemi di supporto. ## Governance della DAO {#dao-governance} -Ci sono molte considerazioni da fare governando una DAO, ad esempio, come funzionano le votazioni e le proposte. +Ci sono molte considerazioni governando una DAO, come il funzionamento di votazioni e proposte. ### Delegazione {#governance-delegation} -Una delegazione è la versione della democrazia rappresentativa della DAO. I titolari di token delegano i voti agli utenti da loro stessi nominati e si impegnano a gestire il protocollo e a rimanere informati. +Una delegazione è la versione della DAO, della democrazia rappresentativa. I titolari di token delegano i voti agli utenti, che si nominano e impegnano alla salvaguardia del protocollo e a rimanere informati. #### Un celebre esempio {#governance-example} -[ENS](https://claim.ens.domains/delegate-ranking) – I titolari di ENS possono delegare i propri voti a membri impegnati della community perché li rappresentino. +[ENS](https://claim.ens.domains/delegate-ranking): I titolari di ENS possono delegare i propri voti ai membri impegnati della community, affinché li rappresentino. ### Governance automatica delle transazioni {#governance-example} -In molte DAO, le transazioni saranno eseguite automaticamente se un quorum dei membri vota in modo affermativo. +In molte DAO, le transazioni saranno eseguite automaticamente se un quorum di membri vota in modo affermativo. #### Un celebre esempio {#governance-example} -[Nouns](https://nouns.wtf) – Nelle DAO di Nouns, una transazione è eseguita automaticamente al raggiungimento di un quorum di voti e una maggioranza di voti affermativi, se non ha ricevuto veti dai fondatori. +[Nouns](https://nouns.wtf): Nella DAO di Nouns, una transazione è eseguita automaticamente se è raggiunto un quorum di voti e una maggioranza vota in modo affermativo, se non ha ricevuto veti dai fondatori. ### Governance multifirma {#governance-example} -Mentre le DAO potrebbero avere migliaia di membri votanti, i fondi possono vivere in un portafoglio condiviso da 5-20 membri attivi della community, ritenuti affidabili e solitamente doxxati (identità pubbliche note alla community). Dopo un voto, i firmatari multifirma eseguono la volontà della community. +Mentre le DAO potrebbero avere migliaia di membri votati, i fondi possono risiedere in un portafoglio condiviso da 5-20 membri della community attivi, affidati e solitamente doxxati (identità pubbliche, note alla community). Dopo un voto, i firmatari multifirma eseguono la volontà della community. ## Leggi sulle DAO {#dao-laws} -Nel 1977, il Wyoming inventò la LLC, che protegge gli imprenditori e ne limita le responsabilità. Più di recente, lo Stato è stato il pioniere della legge sulle DAO, che stabilisce lo status giuridico delle DAO. Al momento, Wyoming, Vermont e le Isole Vergini hanno una qualche forma di legge sulle DAO. +Nel 1977, il Wyoming inventò la LLC, che protegge gli imprenditori e ne limita le responsabilità. Più di recente, lo Stato è stato il pioniere della legge sulle DAO, che ne stabilisce lo stato legale. Al momento, Wyoming, Vermont e Isole Vergini hanno una qualche forma di leggi sulle DAO. #### Un celebre esempio {#law-example} -[CityDAO](https://citydao.io) – CityDao ha utilizzato la legge sulle DAO del Wyoming per acquistare 40 acri di terreno nei pressi del Parco Nazionale di Yellowstone. +[CityDAO](https://citydao.io): Ha sfruttato la legge sulle DAO del Wyoming per acquistare 40 acri di terreno, nei pressi del Parco Nazionale di Yellowstone. -## Aderire a una DAO {#dao-membership} +## Adesione alla DAO {#dao-membership} -Ci sono diversi modelli per aderire a una DAO. L'adesione può determinare come funziona il voto e altri aspetti chiave della DAO. +Esistono diversi modelli per aderire a una DAO. L'adesione può determinare il funzionamento del voto e di altri aspetti chiave della DAO. ### Adesione basata su token {#token-based-membership} -In genere è completamente senza permessi, a seconda del token utilizzato. Questi token di governance possono essere per lo più scambiati senza permessi su uno scambio decentralizzato. Altri, invece, devono esser guadagnati fornendo liquidità o altri tipi di "Proof of Work". In entrambi i casi, la semplice detenzione del token garantisce l'accesso al voto. +Solitamente, completamente priva di permessi, a seconda del token utilizzato. Principalmente, tali token di governance sono scambiabili senza permessi su una piattaforma di scambio decentralizzata. Altri, invece, devono essere guadagnati fornendo liquidità o altri tipi di 'proof-of-work'. In entrambi i casi, semplicemente detenere il token concede l'accesso al voto. -_Di solito usato per governare ampi protocolli decentralizzati e/o i token stessi._ +_Tipicamente utilizzato per governare ampi protocolli decentralizzati e/o gli stessi token._ #### Un celebre esempio {#token-example} -[MakerDAO](https://makerdao.com) – Il token MKR di MakerDAO è ampiamente disponibile sugli scambi decentralizzati e chiunque può acquistare il potere di voto sul futuro del protocollo di Maker. +[MakerDAO](https://makerdao.com): Il token MKR di MakerDAO è ampiamente disponibile sulle piattaforme di scambio decentralizzate e chiunque può acquistarne per avere potere di voto sul futuro del protocollo di Maker. ### Adesione basata su quote {#share-based-membership} -I DAO basati su quote sono maggiormente soggetti a permessi, ma comunque abbastanza aperti. Tutti i potenziali membri possono inviare una proposta di adesione alla DAO, solitamente offrendo un tributo di qualche valore sotto forma di token o di lavoro. Le quote rappresentano il potere di voto diretto e la proprietà. I membri possono uscire in qualsiasi momento con la propria quota proporzionale del patrimonio. +Le DAO basate sulle quote sono maggiormente soggette a permessi, ma comunque abbastanza aperte. Tutti i potenziali membri possono inviare una proposta d'adesione alla DAO, offrendo solitamente un tributo di qualche valore, sotto forma di token o lavoro. Le quote rappresentano il potere di voto diretto e la proprietà. I membri possono uscire in qualsiasi momento con la propria quota proporzionale del patrimonio. -_In genere usato per organizzazioni più compatte e incentrate sul fattore umano, come enti di beneficenza, collettivi di lavoratori e club di investimento. Può anche governare protocolli e token._ +_Tipicamente utilizzata per organizzazioni più compatte e incentrate sul fattore umano, quali beneficenze, collettivi di lavoratori e club di investimento. Può anche governare protocolli e token._ #### Un celebre esempio {#share-example} -[MolochDAO](http://molochdao.com/) – MolochDAO si concentra sul finanziamento di progetti Ethereum. Richiede una proposta di adesione in modo che il gruppo possa valutare se il richiedente ha la competenza e il capitale necessari per formulare giudizi informati sui potenziali beneficiari. Non si può semplicemente acquistare l'accesso al DAO sul mercato. +[MolochDAO](http://molochdao.com/): MolochDAO è incentrata sul finanziamento di progetti di Ethereum. Richiede una proposta di adesione, così che il gruppo possa valutare che tu abbia l'esperienza e il capitale per compiere giudizi informati, sui potenziali beneficiari. Non puoi semplicemente acquistare l'accesso alla DAO sul mercato aperto. ### Adesione basata sulla reputazione {#reputation-based-membership} -La reputazione rappresenta la prova di partecipazione e conferisce potere di voto nella DAO. A differenza dell'adesione basata sui token o le quote, le DAO basate sulla reputazione non trasferiscono la proprietà ai collaboratori. La reputazione non può esser comprata, trasferita o delegata; i membri della DAO devono ottenere la reputazione tramite la loro partecipazione. Il voto su catena è privo di permessi e i potenziali membri possono inviare liberamente proposte per unirsi alla DAO e richiedere di ricevere reputazione e token come ricompensa in cambio dei loro contributi. +La reputazione rappresenta la prova di partecipazione e conferisce il potere di voto nella DAO. A differenza dell'adesione basata su token o quote, le DAO basate sulla reputazione non trasferiscono la proprietà ai collaboratori. La reputazione non è acquistabile, trasferibile o delegabile; i membri della DAO devono ottenere la reputazione, tramite la partecipazione. Il voto sulla catena è privo di permessi e i potenziali membri possono inviare liberamente le proposte di adesione alla DAO, richiedendo di ricevere reputazione e token come ricompense, in cambio dei propri contributi. -_Tipicamente usati per lo sviluppo e la governance decentralizzati di protocolli e dApp, ma anche adatti a una serie eterogenea di organizzazioni, quali enti di beneficenza, collettivi di lavoratori, club d'investimento, etc._ +_Utilizzata tipicamente per lo sviluppo decentralizzato e la governance di protocolli e dadpp, nonché idonea a una serie eterogenea di organizzazioni, quali beneficenze, collettivi di lavoratori, club di investimento, etc._ #### Un celebre esempio {#reputation-example} -[DXdao](https://DXdao.eth.link) – DXdao è un collettivo sovrano globale che dal 2019 crea e amministra protocolli e applicazioni decentralizzati. Sfrutta la governance basata sulla reputazione e il consenso olografico per coordinare e gestire i fondi, il che significa che nessuno può comprarsi il potere per influenzarne il futuro. +[DXdao](https://DXdao.eth.link): DXdao è un collettivo sovrano globale che, dal 2019, crea e amministra i protocolli e le applicazioni decentralizzati. Sfrutta la governance basata sulla reputazione e il consenso olografico, per coordinare e gestire i fondi, a significare che nessuno può acquistare il potere di influenzare il futuro. -## Aderisci a / Crea una DAO {#join-start-a-dao} +## Aderire a / Creare una DAO {#join-start-a-dao} ### Aderisci a una DAO {#join-a-dao} -- [Community di Ethereum](/community/get-involved/#decentralized-autonomous-organizations-daos) -- [Lista delle DAO di DAOHaus](https://app.daohaus.club/explore) +- [DAO della community di Ethereum](/community/get-involved/#decentralized-autonomous-organizations-daos) +- [Elenco di DAO di DAOHaus](https://app.daohaus.club/explore) - [Elenco di DAO di Tally.xyz](https://www.tally.xyz) -### Crea una DAO {#start-a-dao} +### Avviare una DAO {#start-a-dao} -- [Evoca una DAO con DAOHaus](https://app.daohaus.club/summon) +- [Avvia una DAO con DAOHaus](https://app.daohaus.club/summon) - [Crea una DAO di Governance con Tally](https://www.tally.xyz/add-a-dao) - [Crea una DAO basata su Aragon](https://aragon.org/product) - [Avvia una colonia](https://colony.io/) @@ -149,17 +149,17 @@ _Tipicamente usati per lo sviluppo e la governance decentralizzati di protocolli ### Articoli sulle DAO {#dao-articles} -- [Che cos'è una DAO?](https://aragon.org/dao) – [Aragon](https://aragon.org/) +- [Che cos'è una DAO?](https://aragon.org/dao): [Aragon](https://aragon.org/) - [Il manuale delle DAO](https://daohandbook.xyz) -- [La casa delle DAO](https://wiki.metagame.wtf/docs/great-houses/house-of-daos) – [Metagame](https://wiki.metagame.wtf/) -- [Che cos'è una DAO e a cosa serve?](https://daohaus.substack.com/p/-what-is-a-dao-and-what-is-it-for) – [DAOhaus](https://daohaus.club/) -- [Come avviare una comunità digitale basata su DAO](https://daohaus.substack.com/p/four-and-a-half-steps-to-start-a) – [DAOhaus](https://daohaus.club/) -- [Che cos'è una DAO?](https://coinmarketcap.com/alexandria/article/what-is-a-dao) – [Coinmarketcap](https://coinmarketcap.com) -- [Cos'è il consenso olografico?](https://medium.com/daostack/holographic-consensus-part-1-116a73ba1e1c) - [DAOstack](https://daostack.io/) -- [Le DAO non sono società: dove è importante la decentralizzazione nelle organizzazioni autonome, di Vitalik](https://vitalik.ca/general/2022/09/20/daos.html) -- [DAO, DAC, DA e altro: una guida incompleta alla terminologia](https://blog.ethereum.org/2014/05/06/daos-dacs-das-and-more-an-incomplete-terminology-guide) - [Blog di Ethereum](https://blog.ethereum.org) +- [La casa delle DAO](https://wiki.metagame.wtf/docs/great-houses/house-of-daos): [Metagame](https://wiki.metagame.wtf/) +- [Che cos'è una DAO e a cosa serve?](https://daohaus.substack.com/p/-what-is-a-dao-and-what-is-it-for): [DAOhaus](https://daohaus.club/) +- [Come avviare una community digitale basata su DAO](https://daohaus.substack.com/p/four-and-a-half-steps-to-start-a): [DAOhaus](https://daohaus.club/) +- [Che cos'è una DAO?](https://coinmarketcap.com/alexandria/article/what-is-a-dao): [Coinmarketcap](https://coinmarketcap.com) +- [Cos'è il consenso olografico?](https://medium.com/daostack/holographic-consensus-part-1-116a73ba1e1c): [DAOstack](https://daostack.io/) +- [Le DAO non sono società: dov'è importante la decentralizzazione nelle organizzazioni decentralizzate, di Vitalik](https://vitalik.ca/general/2022/09/20/daos.html) +- [DAO, DAC, DA e altro: una guida incompleta alla terminologia](https://blog.ethereum.org/2014/05/06/daos-dacs-das-and-more-an-incomplete-terminology-guide): [Blog di Ethereum](https://blog.ethereum.org) ### Video {#videos} - [Che cos'è una DAO nel mondo delle criptovalute?](https://youtu.be/KHm0uUPqmVE) -- [Può una DAO costruire una città?](https://www.ted.com/talks/scott_fitsimones_could_a_dao_build_the_next_great_city) – [TED](https://www.ted.com/) +- [Una DAO può costruire una città?](https://www.ted.com/talks/scott_fitsimones_could_a_dao_build_the_next_great_city): [TED](https://www.ted.com/) diff --git a/src/content/translations/it/developers/docs/apis/backend/index.md b/src/content/translations/it/developers/docs/apis/backend/index.md index 2f721ac1933..c8ee2d3b450 100644 --- a/src/content/translations/it/developers/docs/apis/backend/index.md +++ b/src/content/translations/it/developers/docs/apis/backend/index.md @@ -32,6 +32,12 @@ Queste librerie eliminano buona parte della complessità legata al dover interag - [blockcypher.com](https://www.blockcypher.com/) - [Documentazione](https://www.blockcypher.com/dev/ethereum/) +**Blast by Bware Labs -** **_API decentralizzate per la rete principale e le reti di prova di Ethereum._** + +- [blastapi.io](https://blastapi.io/) +- [Documentazione](https://docs.blastapi.io) +- [Discord](https://discord.com/invite/VPkWESgtvV) + **Infura -** **_L'API Ethereum come servizio_** - [infura.io](https://infura.io) @@ -42,21 +48,33 @@ Queste librerie eliminano buona parte della complessità legata al dover interag - [cloudflare-eth.com](https://cloudflare-eth.com) -**DataHub di Figment -** **_Servizi API Web3 con Rete principale e rete di prova di Ethereum._** +**Nodo cloud di Coinbase-** **_API per l'infrastruttura della Blockchain._** + +- [Nodo in cloud di Coinbase](https://www.coinbase.com/cloud/products/node) +- [Documentazione](https://docs.cloud.coinbase.com/node/reference/welcome-to-node) + +**DataHub di Figment -** **_Servizi API Web3 con la Rete principale e le reti di prova di Ethereum._** - [DataHub](https://www.figment.io/datahub) - [Documentazione](https://docs.figment.io/introduction/what-is-datahub) -**Nodesmith -** **_Accesso dell’API JSON-RPC alla Rete principale e rete di prova Ethereum._** +**NFTPort -** **_Dati di Ethereum e API di Mint._** + +- [nftport.xyz](https://www.nftport.xyz/) +- [Documentazione](https://docs.nftport.xyz/) +- [GitHub](https://github.com/nftport/) +- [Discord](https://discord.com/invite/K8nNrEgqhE) + +**Nodesmith -** **_Accesso dell’API JSON-RPC alla Rete Principale e alle reti di prova di Ethereum._** - [nodesmith.io](https://nodesmith.io/network/ethereum/) - [Documentazione](https://nodesmith.io/docs/#/ethereum/apiRef) -**Ethercluster -** **_Esegui un servizio API Ethereum personalizzato che supporta sia ETH che ETC_** +**Ethercluster -** **_Esegui il tuo servizio API di Ethereum che supporta sia ETH che ETC_** - [ethercluster.com](https://www.ethercluster.com/) -**Catainstack -** **_Nodi Ethereum elastici e dedicati come servizio_** +**Catainstack -** **_Nodi di Ethereum elastici e dedicati come servizio_** - [chainstack.com](https://chainstack.com) - [Documentazione](https://docs.chainstack.com) @@ -74,13 +92,13 @@ Queste librerie eliminano buona parte della complessità legata al dover interag - [web3.py GitHub](https://github.com/ethereum/web3.py) - [web3.py Chat](https://gitter.im/ethereum/web3.py) -**web3j -** **_Libreria di integrazione Java/Android/Kotlin/Scala per Ethereum_** +**web3j -** **_Libreria di integrazione di Java/Android/Kotlin/Scala per Ethereum_** - [GitHub](https://github.com/web3j/web3j) -- [Documentazione](https://docs.web3j.io/) +- [Docs](https://docs.web3j.io/) - [Gitter](https://gitter.im/web3j/web3j) -**Rivet -** **_API Ethereum ed Ethereum Classic come servizio, supportate da software open source_** +**Rivet -** **_API di Ethereum ed Ethereum Classic come servizio, supportate da software open source._** - [rivet.cloud](https://rivet.cloud) - [Documentazione](https://rivet.cloud/docs/) @@ -112,16 +130,34 @@ Queste librerie eliminano buona parte della complessità legata al dover interag - [Documentazione](https://docs.zmok.io/) - [Discord](https://discord.gg/fAHeh3ka6s) +**NOWNodes - _Nodi completi ed esploratori di blocchi._** + +- [NOWNodes.io](https://nownodes.io/) +- [Documentazione](https://documenter.getpostman.com/view/13630829/TVmFkLwy#intro) + +**Moralis**: **_Fornitore di API EVM di livello enterprise._** + +- [moralis.io](http://moralis.io) +- [Documentazione](https://docs.moralis.io/) +- [GitHub](https://github.com/MoralisWeb3) +- [Discord](https://discord.com/invite/KYswaxwEtg) +- [Forum](https://forum.moralis.io/) + +\*_GetBlock- Blockchain-as-a-service per lo sviluppo in Web3_ + +- [GetBlock.io](https://getblock.io/) +- [Documentazione](https://getblock.io/docs/) + ## Letture consigliate {#further-reading} _Conosci una risorsa pubblica che ti è stata utile? Modifica questa pagina e aggiungila!_ ## Argomenti correlati {#related-topics} -- [Nodi e client](/developers/docs/nodes-and-clients/) -- [Framework di sviluppo](/developers/docs/frameworks/) +- [ Nodi e client](/developers/docs/nodes-and-clients/) +- [Quadri di sviluppo](/developers/docs/frameworks/) ## Tutorial correlati {#related-tutorials} - [Set up Web3js to use the Ethereum blockchain in JavaScript](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/) _– Istruzioni per impostare web3.js in un progetto._ -- [Chiamare un contratto intelligente da JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _- Usando il token Dai, impara come chiamare le funzioni dei contratti usando JavaScript_ +- [Chiamare un contratto intelligente da JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/): _Usando il token DAI, impara come chiamare la funzione dei contratti usando JavaScript._ diff --git a/src/content/translations/it/developers/docs/apis/javascript/index.md b/src/content/translations/it/developers/docs/apis/javascript/index.md index 8d7af78c2ad..75732610668 100644 --- a/src/content/translations/it/developers/docs/apis/javascript/index.md +++ b/src/content/translations/it/developers/docs/apis/javascript/index.md @@ -10,7 +10,7 @@ Per questo scopo, ogni client di Ethereum implementa la specifica [JSON-RPC](/de Se desideri utilizzare JavaScript per connetterti a un nodo Ethereum, puoi usare Javascript vanilla, ma tieni presente che ci sono già molte librerie all'interno dell'ecosistema che possono facilitarti la vita. Con queste librerie, gli sviluppatori possono scrivere metodi a una riga intuitivi per inizializzare le richieste RPC JSON (under the hood) che interagiscono con Ethereum. -Sei pregato di notare che, a partire dalla [Fusione](/roadmap/merge/), per operare un nodo occorrono due elementi di software di Ethereum connessi (un client di esecuzione e un client di consenso). Assicurati che il tuo nodo includa sia un client di esecuzione che un client di consenso. Se il tuo nodo non si trova sulla tua macchina locale (ad es. se è in esecuzione su un'istanza AWS), occorrerà aggiornare di conseguenza gli indirizzi IP nel tutorial. Per ulteriori informazioni, consulta la nostra pagina sull'[esecuzione di un nodo](/developers/docs/nodes-and-clients/run-a-node/). +Si noti che, a partire da [La Fusione](/roadmap/merge/), per eseguire un nodo occorrono due elementi di software di Ethereum connessi (un client di esecuzione e un client di consenso). Assicurati che il tuo nodo includa sia un client di esecuzione che un client di consenso. Se il tuo nodo non si trova sulla tua macchina locale (ad es. se è in esecuzione su un'istanza AWS), occorrerà aggiornare di conseguenza gli indirizzi IP nel tutorial. Per ulteriori informazioni, consulta la nostra pagina sull'[esecuzione di un nodo](/developers/docs/nodes-and-clients/run-a-node/). ## Prerequisiti {#prerequisites} @@ -47,7 +47,7 @@ var web3 = new Web3("http://localhost:8545") var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545")) // cambiamento di provider -web3.etProvider("ws://localhost:8546") +web3.setProvider("ws://localhost:8546") // o web3.setProvider(new Web3.providers.WebsocketProvider("ws://localhost:8546")) @@ -275,17 +275,22 @@ ethers.utils.formatEther(balance) - [Documentazione](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api) - [GitHub](https://github.com/alchemyplatform/alchemy-web3) +**viem -** **_Interfaccia TypeScript per Ethereum._** + +- [Documentazione](https://viem.sh) +- [Github](https://github.com/wagmi-dev/viem) + ## Letture consigliate {#further-reading} _Conosci una risorsa pubblica che ti è stata utile? Modifica questa pagina e aggiungila!_ ## Argomenti correlati {#related-topics} -- [Nodi e client](/developers/docs/nodes-and-clients/) -- [Framework di sviluppo](/developers/docs/frameworks/) +- [ Nodi e client](/developers/docs/nodes-and-clients/) +- [Quadri di sviluppo](/developers/docs/frameworks/) ## Tutorial correlati {#related-tutorials} - [Set up Web3js to use the Ethereum blockchain in JavaScript](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/) _– Istruzioni per impostare web3.js in un progetto._ -- [Chiamare un contratto intelligente da JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _- Usando il token DAI, impara come chiamare la funzione dei contratti usando JavaScript._ +- [Calling a Smart Contract from JavaScript](/developers/tutorials/calling-a-smart-contract-from-javascript/) _– Usando il token DAI, impara come funzionano i contratti di chiamata con JavaScript_ - [Sending transactions using web3 and Alchemy](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) _– Istruzioni passo passo per l'invio di transazioni dal backend._ diff --git a/src/content/translations/it/developers/docs/apis/json-rpc/index.md b/src/content/translations/it/developers/docs/apis/json-rpc/index.md index b4681c973d6..86e1394a79c 100644 --- a/src/content/translations/it/developers/docs/apis/json-rpc/index.md +++ b/src/content/translations/it/developers/docs/apis/json-rpc/index.md @@ -6,7 +6,7 @@ lang: it Affinché un'applicazione software interagisca con la blockchain di Ethereum, leggendo i dati della blockchain o inviando transazioni alla rete, deve connettersi a un nodo di Ethereum. -A tale scopo, ogni [client di Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implementa una [specifica JSON-RPC](https://github.com/ethereum/execution-apis), in modo che sia disponibile un insieme di metodi uniformi a cui possono affidarsi le applicazioni, indipendentemente dal nodo specifico o dall'implementazione del client. +Per questo scopo, ogni [client di Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implementa una [specifica JSON-RPC](https://github.com/ethereum/execution-apis), quindi esiste un insieme uniforme di metodi cui le applicazioni possono affidarsi, indipendentemente dagli specifici nodi o implementazioni del client. [JSON-RPC](https://www.jsonrpc.org/specification) è un protocollo di chiamata a procedura remota (RPC) leggero e privo di stato. Definisce diverse strutture di dati e le regole per la loro elaborazione. È indipendente dal trasporto, poiché i concetti sono utilizzabili entro lo stesso processo, su prese, via HTTP o in svariati ambienti di passaggio dei messaggi. Usa JSON (RFC 4627) come formato dei dati. @@ -75,6 +75,8 @@ Le seguenti opzioni sono possibili per il parametro defaultBlock: - `HEX String` - un numero intero del blocco - `String "earliest"` per il primo blocco o quello di genesi - `String "latest"` - per l'ultimo blocco estratto +- `String "safe"` - per l'ultimo blocco di testa sicuro +- `String "finalized"` - per l'ultimo blocco finalizzato - `String "pending"` - per lo stato/le transazioni in sospeso ## Esempi @@ -198,7 +200,11 @@ Nessuno `String` - L'id di rete corrente. -L'elenco completo degli ID di rete correnti è disponibile su [chainlist.org](https://chainlist.org). Alcuni ID comuni sono: `1`: Mainnet di Ethereum `2`: Testnet di Morden (ora deprecata) `3`: Testnet di Ropsten `4`: Testnet di Rinkeby `5`: Testnet di Goerli +L'elenco completo degli ID di rete correnti è disponibile su [chainlist.org](https://chainlist.org). Alcuni ID comuni sono: + +- `1`: Rete Principale di Ethereum +- `5`: rete di prova Goerli +- `11155111`: rete di prova Sepolia **Esempio** @@ -265,7 +271,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"net_peerCount","params":[],"id": ### eth_protocolVersion {#eth_protocolversion} -Restituisce la versione del protocollo di Ethereum corrente. +Restituisce la versione corrente del protocollo di Ethereum. Si noti che questo metodo [non è disponibile su Geth](https://github.com/ethereum/go-ethereum/pull/22064#issuecomment-788682924). **Parametri** @@ -352,9 +358,34 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":6 } ``` +## eth_chainId {#eth_chainId} + +Restituisce l'ID della catena utilizzato per firmare le transazioni protette da riproduzione. + +**Parametri** + +Nessuno + +**Restituisce** + +`chainId`, valore esadecimale come stringa rappresentante l'intero dell'ID della catena corrente. + +**Esempio** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "0x1" +} +``` + ### eth_mining {#eth_mining} -Restituisce `true` se il client sta minando attivamente i nuovi blocchi. +Restituisce `true` se il client sta minando attivamente nuovi blocchi. **Parametri** @@ -404,7 +435,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":7 ### eth_gasPrice {#eth_gasprice} -Restituisce il prezzo corrente del gas in wei. +Restituisce il prezzo corrente del carburante in wei. **Parametri** @@ -412,7 +443,7 @@ Nessuno **Restituisce** -`QUANTITY`: intero del prezzo corrente del gas in wei. +`QUANTITY` - intero del prezzo corrente del carburante in wei. **Esempio** @@ -462,7 +493,7 @@ Nessuno **Restituisce** -`QUANTITY` - Intero del numero di blocco corrente su cui è attivo il client. +`QUANTITY` - intero del numero di blocco corrente su cui è attivo il client. **Esempio** @@ -484,7 +515,7 @@ Restituisce il saldo del conto dell'indirizzo dato. **Parametri** 1. `DATA`, 20 Byte - indirizzo per controllare il saldo. -2. `QUANTITY|TAG` - numero intero del blocco o della stringa `"latest"`, `"earliest"` or `"pending"`, vedi il [parametro del blocco predefinito](/developers/docs/apis/json-rpc/#default-block-parameter) +2. `QUANTITY|TAG` - numero intero del blocco, o stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block) ```js params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"] @@ -514,14 +545,14 @@ Restituisce il valore da una posizione di archiviazione a un dato indirizzo. **Parametri** 1. `DATA`, 20 Bytes - Indirizzo di archiviazione. -2. `QUANTITY` - Intero nella posizione di archiviazione. -3. `QUANTITY|TAG` - Numero di blocco intero o stringa`"latest"`, `"earliest"` o `"pending"`. Vedi il [parametro di blocco predefinito](/developers/docs/apis/json-rpc/#default-block-parameter) +2. `QUANTITY` - intero della posizione di archiviazione. +3. `QUANTITY|TAG` - numero intero del blocco, o stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block) **Restituisce** -`DATA` - Il valore in questa posizione di archiviazione. +`DATA` - il valore in questa posizione di archiviazione. -**Esempio** Il calcolo della posizione corretta dipende dalla memoria da recuperare. Considera il seguente contratto, distribuito su `0x295a70b2de5e3953354a6a8344e616ed314d7251` dall'indirizzo `0x391694e7e0b0cce554cb130d723a9d27458f9298`. +**Esempio** Il calcolo della posizione corretta dipende dall'archiviazione da recuperare. Considera il seguente contratto distribuito su `0x295a70b2de5e3953354a6a8344e616ed314d7251` dall'indirizzo `0x391694e7e0b0cce554cb130d723a9d27458f9298`. ``` contract Storage { @@ -547,7 +578,7 @@ Recuperare un elemento della mappa è più difficile. La posizione di un element keccack(LeftPad32(key, 0), LeftPad32(map position, 0)) ``` -Ciò significa che per recuperare lo storage su pos1["0x391694e7e0b0cce554cb130d723a9d27458f9298"] dobbiamo calcolare la posizione con: +Ciò significa che per recuperare l'archiviazione in pos1["0x391694e7e0b0cce554cb130d723a9d27458f9298"] dobbiamo calcolare la posizione con: ```js keccak( @@ -567,7 +598,7 @@ undefined "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9" ``` -A questo punto, per recuperare lo spazio di archiviazione: +A questo punto, per recuperare l'archiviazione: ```js curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"], "id": 1}' localhost:8545 @@ -576,12 +607,12 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [ ### eth_getTransactionCount {#eth_gettransactioncount} -Restituisce il numero di transazioni _inviate_ da un'indirizzo. +Restituisce il numero di transazioni _inviate_ da un indirizzo. **Parametri** 1. `DATA`, 20 Bytes - indirizzo. -2. `QUANTITY|TAG` - numero intero del blocco o stringa `"latest"`, `"earliest"` o `"pending"`. Vedi il [parametro del blocco predefinito](/developers/docs/apis/json-rpc/#default-block-parameter) +2. `QUANTITY|TAG` - numero intero del blocco, o stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block) ```js params: [ @@ -642,7 +673,7 @@ Restituisce il numero di transazioni in un blocco corrispondente al numero di bl **Parametri** -1. `QUANTITY|TAG` - numero intero del blocco o stringa `"latest"`, `"earliest"` o `"pending"`. Vedi il [parametro del blocco predefinito](/developers/docs/apis/json-rpc/#default-block-parameter). +1. `QUANTITY|TAG` - numero intero del blocco, o stringa `"earliest"`, `"latest"` o `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block). ```js params: [ @@ -652,7 +683,7 @@ params: [ **Restituisce** -`QUANTITY` - Intero del numero di transazioni in questo blocco. +`QUANTITY` - intero del numero di transazioni in questo blocco. **Esempio** @@ -681,7 +712,7 @@ params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] **Restituisce** -`QUANTITY` - Il numero intero di ommer in questo blocco. +`QUANTITY` - intero del numero di ommer in questo blocco. **Esempio** @@ -702,7 +733,7 @@ Restituisce il numero di ommer in un blocco da un blocco che corrisponde all'has **Parametri** -1. `QUANTITY|TAG` - Intero del numero di blocco o stringa "latest", "earliest" o "pending". Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block-parameter) +1. `QUANTITY|TAG` - intero del numero di blocco, o stringa "latest", "earliest" o "pending". Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block) ```js params: [ @@ -712,7 +743,7 @@ params: [ **Restituisce** -`QUANTITY` - Il numero intero di ommer in questo blocco. +`QUANTITY` - intero del numero di ommer in questo blocco. **Esempio** @@ -734,7 +765,7 @@ Restituisce il codice ad un indirizzo specificato. **Parametri** 1. `DATA`, 20 Bytes - indirizzo -2. `QUANTITY|TAG` - numero intero del blocco o la stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro del blocco predefinito](/developers/docs/apis/json-rpc/#default-block-parameter) +2. `QUANTITY|TAG` - numero intero del blocco, o stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block) ```js params: [ @@ -745,7 +776,7 @@ params: [ **Restituisce** -`DATI` - il codice dall'indirizzo specificato. +`DATA` - il codice dall'indirizzo specificato. **Esempio** @@ -771,11 +802,11 @@ Nota: l'indirizzo con cui firmare deve essere sbloccato. **Parametri** 1. `DATA`, 20 Bytes - indirizzo -2. `DATI`, N Byte - messaggio da firmare +2. `DATA`, N Byte - messaggio da firmare **Restituisce** -`DATI`: Firma +`DATA`: Firma **Esempio** @@ -796,19 +827,19 @@ Firma una transazione che può essere inviata alla rete in un secondo momento ut **Parametri** -1. `Oggetto` - L'oggetto della transazione +1. `Object` - L'oggetto della transazione - `from`: `DATI`, 20 Bytes - L'indirizzo da cui viene inviata la transazione. - `to`: `DATI`, 20 Bytes - (opzionale quando si crea un nuovo contratto) L'indirizzo a cui è indirizzata la transazione. -- `gas`: `QUANTITÀ`: (facoltativo, predefinito: 90000) Intero del gas fornito per l'esecuzione della transazione. Restituirà il gas inutilizzato. -- `gasPrice`: `QUANTITY`: (facoltativo, predefinito: To-Be-Determined) Intero del gasPrice usato per ogni gas pagato, in Wei. -- `value`: `QUANTITÀ` - (opzionale) Intero del valore inviato con questa transazione, in Wei. +- `gas`: `QUANTITY`: (facoltativo, prededfinito: 90000) Intero del gas fornito per l'esecuzione della transazione. Restituirà il gas inutilizzato. +- `gasPrice`: `QUANTITY` - (facoltativo, predefinito: To-Be-Determined) Intero del gasPrice usato per ogni unità di carburante pagata, in Wei. +- `value`: `QUANTITY` - (facoltativo) Intero del valore inviato con questa transazione, in Wei. - `data`: `DATI` - Il codice compilato di un contratto OPPURE l'hash della firma del metodo richiamato e i parametri codificati. -- `nonce`: `QUANTITÀ` - (opzionale) Intero di una nonce. Ciò permette di sovrascrivere le proprie transazioni in sospeso che utilizzano la stessa nonce. +- `nonce`: `QUANTITÀ` - (opzionale) Intero di una nonce. Questo permette di sovrascrivere le tue transazioni in sospeso che utilizzano la stessa nonce. **Restituisce** -`DATI`, L'oggetto della transazione firmato. +`DATA`, L'oggetto della transazione firmato. **Esempio** @@ -825,19 +856,19 @@ curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction"," ### eth_sendTransaction {#eth_sendtransaction} -Se il campo dati contiene il codice, crea una nuova transazione via messaggio o la stipula di un contratto. +Se il campo dati contiene codice, crea una nuova transazione di chiamata di messaggio o la stipula di un contratto. **Parametri** 1. `Oggetto` - L'oggetto della transazione -- `from`: `DATI`, 20 Bytes - L'indirizzo da cui viene inviata la transazione. -- `to`: `DATI`, 20 Bytes - (opzionale quando si crea un nuovo contratto) L'indirizzo a cui è indirizzata la transazione. -- `gas`: `QUANTITY`: (facoltativo, prededfinito: 90000) Intero del gas fornito per l'esecuzione della transazione. Restituirà il gas inutilizzato. -- `gasPrice`: `QUANTITY`: (facoltativo, predefinito: To-Be-Determined) Intero del gasPrice usato per ogni gas pagato. -- `value`: `QUANTITÀ` - (opzionale) Intero del valore inviato con questa transazione, in Wei. -- `data`: `DATI` - Il codice compilato di un contratto OPPURE l'hash della firma del metodo richiamato e i parametri codificati. -- `nonce`: `QUANTITÀ` - (opzionale) Intero di una nonce. Questo permette di sovrascrivere le tue transazioni in sospeso che utilizzano la stessa nonce. +- `from`: `DATA`, 20 Bytes - L'indirizzo da cui viene inviata la transazione. +- `to`: `DATA`, 20 Bytes - (opzionale quando si crea un nuovo contratto) L'indirizzo a cui è indirizzata la transazione. +- `gas`: `QUANTITY` - (facoltativo, predefinito: 90000) Intero del carburante fornito per l'esecuzione della transazione. Restituirà il carburante inutilizzato. +- `gasPrice`: `QUANTITY` - (facoltativo, predefinito: To-Be-Determined) Intero del gasPrice usato per ogni unità di carburante pagata. +- `value`: `QUANTITY` - (facoltativo) Intero del valore inviato con questa transazione, in Wei. +- `data`: `DATA` - Il codice compilato di un contratto OPPURE l'hash della firma del metodo richiamato e i parametri codificati. +- `nonce`: `QUANTITY` - (facoltativo) Intero di un nonce. Ciò permette di sovrascrivere le proprie transazioni in sospeso che utilizzano lo stesso nonce. ```js params: [ @@ -873,7 +904,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{ ### eth_sendRawTransaction {#eth_sendrawtransaction} -Se il campo dati contiene il codice, crea una nuova transazione via messaggio o la stipula di un contratto,. +Crea una nuova transazione di chiamata di messaggio o la stipula di un contratto, per le transazioni firmate. **Parametri** @@ -887,9 +918,9 @@ params: [ **Restituisce** -`DATI`, 32 Bytes - l'hash della transazione, o l'hash zero se la transazione non è ancora disponibile. +`DATA`, 32 Bytes - l'hash della transazione, o l'hash zero se la transazione non è ancora disponibile. -Usa [eth_getTransactionReceipt](#eth_gettransactionreceipt) quando hai creato un contratto per ottenere l'indirizzo del contratto, dopo che la transazione è stata minata. +Usa [eth_getTransactionReceipt](#eth_gettransactionreceipt) quando hai creato un contratto per ottenere l'indirizzo del contratto dopo che la transazione è stata minata. **Esempio** @@ -906,20 +937,20 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params" ### eth_call {#eth_call} -Esegue immediatamente un nuovo messaggio di chiamata senza creare una transazione nella catena di blocchi. +Esegue immediatamente una nuova chiamata di messaggio senza creare una transazione nella blockchain. **Parametri** -1. `Oggetto` - L'oggetto della chiamata della transazione +1. `Object` - L'oggetto della chiamata della transazione -- `from`: `DATA`, 20 Bytes - (opzionale) L'indirizzo da cui viene inviata la transazione. +- `from`: `DATA`, 20 Bytes - (facoltativo) L'indirizzo da cui viene inviata la transazione. - `to`: `DATA`, 20 Bytes - L'indirizzo a cui è indirizzata la transazione. -- `gas`: `QUANTITY`: (facoltativo) Intero del gas fornito per l'esecuzione della transazione. eth_call consuma zero gas, ma questo parametro potrebbe essere necessario per alcune esecuzioni. -- `gasPrice`: `QUANTITY`: (facoltativo) Intero del gasPrice usato per ogni gas pagato -- `value`: `QUANTITY` - (opzionale) Intero del valore inviato con questa transazione -- `data`: `DATA` - (opzionale) Hash del metodo di firma e dei parametri codificati. Per maggiori dettagli consulta [Ethereum Contract ABI nella documentazione di Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html) +- `gas`: `QUANTITY` - (facoltativo) Intero del carburante fornito per l'esecuzione della transazione. eth_call consuma zero carburante, ma questo parametro potrebbe essere necessario per alcune esecuzioni. +- `gasPrice`: `QUANTITY` - (facoltativo) Intero del gasPrice usato per ogni unità di carburante pagata +- `value`: `QUANTITY` - (facoltativo) Intero del valore inviato con questa transazione +- `data`: `DATA` - (facoltativo) Hash della firma del metodo e dei parametri codificati. Per maggiori dettagli consulta [Ethereum Contract ABI nella documentazione di Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html) -2. `QUANTITY|TAG` - numero intero del blocco o stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block-parameter) +2. `QUANTITY|TAG` - numero intero del blocco, o stringa `"latest"`, `"earliest"` o `"pending"`. Vedere il [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block) **Restituisce** @@ -940,15 +971,15 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}] ### eth_estimateGas {#eth_estimategas} -Genera e restituisce una stima di quanto gas è necessario per consentire il completamento della transazione. La transazione non verrà aggiunta alla blockchain. Nota che la stima potrebbe esser significativamente superiore all'importo di gas effettivamente usato dall'operazione, per vari motivi, incluse le meccaniche dell'EVM e le prestazioni del nodo. +Genera e restituisce una stima di quanto carburante è necessario per consentire il completamento della transazione. La transazione non verrà aggiunta alla blockchain. Nota che la stima potrebbe esser significativamente superiore all'importo di carburante effettivamente usato dall'operazione, per vari motivi, incluse le meccaniche dell'EVM e le prestazioni del nodo. **Parametri** -Vedi i parametri [eth_call](#eth_call), tutte le proprietà dovrebbero essere opzionali. Se non è specificato alcun limite di gas, geth usa il limite di gas del blocco dal blocco in sospeso come limite massimo. Di conseguenza, la stima restituita potrebbe non esser sufficiente per eseguire la chiamata/transazione quando l'importo di gas è maggiore del limite di gas del blocco. +Vedi i parametri di [eth_call](#eth_call), tranne che tutte le proprietà sono facoltative. Se non è specificato alcun limite di carburante, geth usa il limite di carburante del blocco dal blocco in sospeso come limite massimo. Di conseguenza, la stima restituita potrebbe non esser sufficiente per eseguire la chiamata/transazione quando l'importo di carburante è superiore al limite di carburante del blocco. **Restituisce** -`QUANTITY`: l'importo di gas utilizzato. +`QUANTITY` - la quantità di carburante utilizzato. **Esempio** @@ -981,27 +1012,27 @@ params: [ **Restituisce** -`Oggetto` - Un oggetto blocco, o `null` quando non viene trovato alcun blocco: +`Object` - Un oggetto blocco, o `null` quando non viene trovato alcun blocco: - `number`: `QUANTITY` - il numero di blocco. `null` quando è in attesa del blocco. - `hash`: `DATA`, 32 Bytes - hash del blocco. `null` quando è in attesa del blocco. -- `hash`: `DATA`, 32 Bytes - hash del blocco padre. +- `hash`: `DATA`, 32 Bytes - hash del blocco genitore. - `nonce`: `DATA`, 8 Bytes - hash del proof-of-work generato. `null` quando è in attesa del blocco. - `sha3Uncles`: `DATA`, 32 Bytes - SHA3 dei dati ommer del blocco. -- `logsBloom`: `DATA`, 256 Bytes - il Bloom Filter per i registri del blocco. `null` quando è in attesa del blocco. +- `logsBloom`: `DATA`, 256 Bytes - il filtro bloom per i registri del blocco. `null` quando è in attesa del blocco. - `transactionsRoot`: `DATA`, 32 Bytes - la radice dell'albero delle transazioni del blocco. - `stateRoot`: `DATA`, 32 Bytes - la radice dell'albero di stato finale del blocco. -- `receiptsRoot`: `DATI`, 32 Bytes - la radice dell'albero delle ricevute del blocco. -- `miner`: `DATI`, 20 Bytes - l'indirizzo del beneficiario a cui sono state fornite le ricompense di mining. -- `difficoltà`: `QUANTITÀ` - intero della difficoltà per questo blocco. +- `receiptsRoot`: `DATA`, 32 Bytes - la radice dell'albero delle ricevute del blocco. +- `miner`: `DATA`, 20 Bytes - l'indirizzo del beneficiario a cui sono state fornite le ricompense di mining. +- `difficulty`: `QUANTITY` - intero della difficoltà per questo blocco. - `totalDifficulty`: `QUANTITY` - intero della difficoltà totale della catena fino a questo blocco. - `extraData`: `DATA` - il campo "dati extra" di questo blocco. - `size`: `QUANTITY` - intero in bytes della dimensione di questo blocco. -- `gasLimit`: `QUANTITY`: il gas massimo consentito in questo blocco. -- `gasUsed`: `QUANTITY`: il gas totale usato da tutte le transazioni in questo blocco. +- `gasLimit`: `QUANTITY` - il carburante massimo consentito in questo blocco. +- `gasUsed`: `QUANTITY` - il carburante totale usato da tutte le transazioni in questo blocco. - `timestamp`: `QUANTITY` - la marca temporale unix relativa a quando il blocco è stato collazionato. -- `transactions`: `Array` - Matrice di oggetti transazione o hash di transazione da 32 byte a seconda dell'ultimo parametro specificato. -- `uncles`: `Array` - Matrice di ommer hash. +- `transactions`: `Array` - Array di oggetti transazione, o hash di transazione da 32 Bytes a seconda dell'ultimo parametro specificato. +- `uncles`: `Array` - Array di hash ommer. **Esempio** @@ -1046,7 +1077,7 @@ Restituisce informazioni su un blocco per numero di blocco. **Parametri** -1. `QUANTITY|TAG` - numero intero del blocco o stringa `"earliest"`, `"latest"` oppure `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block-parameter). +1. `QUANTITY|TAG` - numero intero del blocco, o stringa `"earliest"`, `"latest"` o `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block). 2. `Boolean` - Se `true` restituisce gli oggetti di transazione completi, se `falso` solo gli hash delle transazioni. ```js @@ -1081,20 +1112,20 @@ params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"] **Restituisce** -`Oggetto` - Un oggetto di transazione, oppure `null` quando non viene trovata alcuna transazione: +`Object` - Un oggetto transazione, oppure `null` quando non viene trovata alcuna transazione: - `blockHash`: `DATA`, 32 byte - hash del blocco in cui si trovava questa transazione. `null` quando è in sospeso. - `blockNumber`: `QUANTITY` - numero di blocco in cui si trovava questa transazione. `null` quando è in sospeso. -- `from`: `DATA`, 20 Bytes - l'indirizzo del mittente. -- `gas`: `QUANTITY`: gas fornito dal mittente. -- `gasPrice`: `QUANTITY`: prezzo del gas fornito dal mittente in Wei. +- `from`: `DATA`, 20 Bytes - indirizzo del mittente. +- `gas`: `QUANTITY` - carburante fornito dal mittente. +- `gasPrice`: `QUANTITY` - prezzo del carburante fornito dal mittente in Wei. - `hash`: `DATA`, 32 Bytes - hash della transazione. - `input`: `DATA` - i dati inviati insieme alla transazione. - `nonce`: `QUANTITY` - il numero di transazioni effettuate dal mittente prima di questa. - `to`: `DATA`, 20 Bytes - l'indirizzo del destinatario. `null` quando è una transazione di creazione del contratto. - `transactionIndex`: `QUANTITY` - intero della posizione dell'indice delle transazioni nel blocco. `null` quando è in sospeso. - `value`: `QUANTITY` - valore trasferito in Wei. -- `v`: `QUANTITY` - id di recupero ECDSA +- `v`: `QUANTITY` - ID di recupero ECDSA - `r`: `QUANTITY` - firma r ECDSA - `s`: `QUANTITY` - firma s ECDSA @@ -1128,7 +1159,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","param ### eth_getTransactionByBlockHashAndIndex {#eth_gettransactionbyblockhashandindex} -Restituisce informazioni su una transazione per hash del blocco e posizione dell'indice delle transazioni. +Restituisce informazioni su una transazione per hash del blocco e posizione dell'indice della transazione. **Parametri** @@ -1155,12 +1186,12 @@ Risultato vedi [eth_getBlockByHash](#eth_gettransactionbyhash) ### eth_getTransactionByBlockNumberAndIndex {#eth_gettransactionbyblocknumberandindex} -Restituisce informazioni su una transazione per hash del blocco e posizione dell'indice delle transazioni. +Restituisce informazioni su una transazione per hash del blocco e posizione dell'indice della transazione. **Parametri** -1. `QUANTITY|TAG` - numero intero del blocco o stringa `"earliest"`, `"latest"` oppure `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block-parameter). -2. `QUANTITY` - la posizione dell'indice delle transazioni. +1. `QUANTITY|TAG` - intero del blocco, o stringa `"earliest"`, `"latest"` oppure `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block). +2. `QUANTITY` - la posizione dell'indice della transazione. ```js params: [ @@ -1182,7 +1213,7 @@ Risultato vedi [eth_getBlockByHash](#eth_gettransactionbyhash) ### eth_getTransactionReceipt {#eth_gettransactionreceipt} -Restituisce la ricezione di una transazione tramite l'hash di transazione. +Restituisce la ricevuta di una transazione tramite l'hash di transazione. **Nota** che la ricevuta non è disponibile per le transazioni in sospeso. @@ -1191,47 +1222,55 @@ Restituisce la ricezione di una transazione tramite l'hash di transazione. 1. `DATA`, 32 Bytes - hash di una transazione ```js -params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] +params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"] ``` -**Restituisce** `Object` - Un oggetto di ricezione della transazione o `null` quando non è stata trovata nessuna ricevuta: +**Restituisce** `Object` - Un oggetto ricevuta della transazione, o `null` quando non è stata trovata nessuna ricevuta: - `transactionHash`: `DATA`, 32 Bytes - hash della transazione. -- `transactionIndex`: `QUANTITY` - numero intero della posizione dell'indice delle transazioni nel blocco. +- `transactionIndex`: `QUANTITY` - intero della posizione dell'indice delle transazioni nel blocco. - `blockHash`: `DATA`, 32 byte - hash del blocco in cui si trovava questa transazione. - `blockNumber`: `QUANTITY` - numero di blocco in cui si trovava questa transazione. -- `from`: `DATA`, 20 Bytes - l'indirizzo del mittente. +- `from`: `DATA`, 20 Bytes - indirizzo del mittente. - `to`: `DATA`, 20 Bytes - l'indirizzo del destinatario. null quando è una transazione di creazione del contratto. -- `cumulativeGasUsed`: `QUANTITY`: L'importo totale di gas usato all'esecuzione nel blocco di questa transazione. -- `gas Usato`: `QUANTITÀ`: L'importo di gas usato solo da questa specifica transazione. +- `cumulativeGasUsed`: `QUANTITY` - La quantità totale di carburante usato nel blocco per l'esecuzione della transazione. +- `effectiveGasPrice` : `QUANTITY` - La somma della commissione di base e delle mance pagata per unità di carburante. +- `gasUsed`: `QUANTITY` - La quantità di carburante usato solo da questa specifica transazione. - `contractAddress`: `DATA`, 20 Bytes - L'indirizzo del contratto creato, se la transazione consisteva nella creazione di un contratto, altrimenti `null`. -- `logs`: `Array` - Array di oggetti di registro che questa transazione ha generato. -- `logsBloom`: `DATA`, 256 Bytes - Filtro Bloom per i client leggeri per recuperare rapidamente i log correlati. Restituisce anche _either_: -- `root` : `DATA` 32 bytes dello stateRoot post-transazione (pre Byzantium) +- `logs`: `Array` - Array di oggetti di registro generati da questa transazione. +- `logsBloom`: `DATA`, 256 Bytes - Filtro Bloom per i client leggeri per recuperare rapidamente i registri correlati. +- `type`: `QUANTITY` - intero del tipo di transazione, `0x0` per le transazioni ereditarie, `0x1` per i tipi di elenco d'accesso, `0x2` per le commissioni dinamiche. Restituisce anche _in alternativa_: +- `root` : `DATA` 32 bytes dello stateroot post-transazione (pre Byzantium) - `status`: `QUANTITY` o `1` (successo) o `0` (insuccesso) **Esempio** ```js // Request -curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"],"id":1}' +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"],"id":1}' // Result { -"id":1, -"jsonrpc":"2.0", -"result": { - transactionHash: '0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238', - transactionIndex: '0x1', // 1 - blockNumber: '0xb', // 11 - blockHash: '0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b', - cumulativeGasUsed: '0x33bc', // 13244 - gasUsed: '0x4dc', // 1244 - contractAddress: '0xb60e8dd61c5d32be8058bb8eb970870f07233155', // or null, if none was created - logs: [{ - // logs as returned by getFilterLogs, etc. - }, ...], - logsBloom: "0x00...0", // 256 byte bloom filter - status: '0x1' + "jsonrpc": "2.0", + "id": 1, + "result": { + "blockHash": + "0xa957d47df264a31badc3ae823e10ac1d444b098d9b73d204c40426e57f47e8c3", + "blockNumber": "0xeff35f", + "contractAddress": null, // string of the address if it was created + "cumulativeGasUsed": "0xa12515", + "effectiveGasPrice": "0x5a9c688d4", + "from": "0x6221a9c005f6e47eb398fd867784cacfdcfff4e7", + "gasUsed": "0xb4c8", + "logs": [{ + // logs as returned by getFilterLogs, etc. + }], + "logsBloom": "0x00...0", // 256 byte bloom filter + "status": "0x1", + "to": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", + "transactionHash": + "0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5", + "transactionIndex": "0x66", + "type": "0x2" } } ``` @@ -1271,7 +1310,7 @@ Restituisce informazioni su un ommer di un blocco in base al numero e alla posiz **Parametri** -1. `QUANTITY|TAG` - numero intero del blocco o stringa `"earliest"`, `"latest"` oppure `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block-parameter). +1. `QUANTITY|TAG` - intero del blocco, o stringa `"earliest"`, `"latest"` oppure `"pending"`, come nel [parametro predefinito del blocco](/developers/docs/apis/json-rpc/#default-block). 2. `QUANTITY` - la posizione dell'indice dell'ommer. ```js @@ -1432,23 +1471,23 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileSerpent","params":["/ ### eth_newFilter {#eth_newfilter} -Crea un oggetto filtro, basato sulle opzioni di filtro, per notificare quando lo stato cambia (log). Per verificare se lo stato è cambiato, chiama [eth_getFilterChanges](#eth_getfilterchanges). +Crea un oggetto filtro, basato sulle opzioni di filtro, per notificare quando lo stato cambia (registri). Per verificare se lo stato è cambiato, chiama [eth_getFilterChanges](#eth_getfilterchanges). **Una nota per specificare i filtri degli argomenti:** Gli argomenti dipendono dall'ordine. Una transazione con un registro con argomenti [A, B] sarà abbinata ai seguenti filtri tematici: - `[]` "qualsiasi" - `[A]`: "A in prima posizione (e tutto il resto segue)" -- `[null, B]`: "tutto nella prima posizione e B nella seconda (e tutto il resto segue)" -- `[A, B]`: "A in prima posizione e B in seconda (e tutto il resto segue)" -- `[[A, B], [A, B]]`: "(A o B) in prima posizione e (A o B) in seconda posizione (e tutto il resto segue)" +- `[null, B]`: "tutto nella prima posizione AND B nella seconda (e tutto il resto segue)" +- `[A, B]`: "A in prima posizione AND B in seconda (e tutto il resto segue)" +- `[[A, B], [A, B]]`: "(A OR B) in prima posizione AND (A OR B) in seconda posizione (e tutto il resto segue)" - **Parametri** 1. `Object` - Le opzioni di filtro: -- `fromBlock`: `QUANTITY|TAG` - (opzionale, predefinito: `"latest"`) Numero intero del blocco, oppure `"latest"` per l'ultimo blocco estratto oppure `"pending"`, `"earliest"` per le transazioni ancore non estratte. -- `toBlock`: `QUANTITY|TAG` - (opzionale, predefinito: `"latest"`) numero intero del block, oppure `"latest"` per l'ultimo blocco estratto, oppure `"pending"`, `"earliest"` per le transazioni ancora non estratte. -- `address`: `DATA|Array`, 20 Bytes - (opzionale) Gli indirizzi del contratto oppure un elenco di indirizzi da cui dovrebbero avere origine i registri. -- `topics`: `Array of DATA`, - (opzionale) Array di 32 Bytes `DATA` Argomento. Argomenti di analisi della dipendenza dei dati. Ogni argomento può anche essere una matrice di DATI con opzioni "oppure". +- `fromBlock`: `QUANTITY|TAG` - (facoltativo, predefinito: `"latest"`) Intero del numero di blocco, oppure `"latest"` per l'ultimo blocco minato oppure `"pending"`, `"earliest"` per le transazioni non ancora minate. +- `toBlock`: `QUANTITY|TAG` - (facoltativo, predefinito: `"latest"`) Intero del numero di blocco, oppure `"latest"` per l'ultimo blocco minato, oppure `"pending"`, `"earliest"` per le transazioni non ancora minate. +- `address`: `DATA|Array`, 20 Bytes - (facoltativo) Indirizzo del contratto oppure un elenco di indirizzi da cui dovrebbero avere origine i registri. +- `topics`: `Array of DATA`, - (facoltativo) Array di argomenti `DATA` a 32 byte. Gli argomenti dipendono dall'ordine. Ogni argomento può anche essere un array di DATI con opzioni "or". ```js params: [ @@ -1510,7 +1549,7 @@ Crea un filtro nel nodo, per avvisare quando arrivano nuove transazioni in sospe **Parametri** Nessuno -**Restituisce** `QUANTITY` - Un filtro ID. +**Restituisce** `QUANTITY` - L'ID di un filtro. **Esempio** @@ -1527,7 +1566,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter" ### eth_uninstallFilter {#eth_uninstallfilter} -Disinstalla un filtro con un Id specificato. Dovrebbe essere sempre chiamato quando l'orologio non è più necessario. Inoltre i filtri scadono quando non vengono richiesti con [eth_getFilterChanges](#eth_getfilterchanges) per un periodo di tempo. +Disinstalla un filtro con un ID specificato. Dovrebbe essere sempre chiamato quando l'orologio non è più necessario. Inoltre, i filtri scadono quando non vengono richiesti con [eth_getFilterChanges](#eth_getfilterchanges) per un periodo di tempo. **Parametri** @@ -1568,20 +1607,20 @@ params: [ ] ``` -**Restituisce** `Array` - Array di oggetti di log, o un array vuoto se nulla è cambiato dall'ultimo sondaggio. +**Restituisce** `Array` - Array di oggetti registro, o un array vuoto se nulla è cambiato dall'ultimo sondaggio. - Per i filtri creati con `eth_newBlockFilter` vengono restituiti hash di blocco (`DATA`, 32 Byte), ad esempio `["0x3454645634534..."]`. - Per i filtri creati con `eth_newPendingTransactionFiltro` vengono restituiti hash di transazione (`DATA`, 32 Bytes), ad esempio `["0x6345343454645..."]`. - Per i filtri creati con `eth_newFiltro` i registri sono oggetti con i seguenti parametri: - - `removed`: `TAG` - `true` quando il registro è stato rimosso, a causa di una riorganizzazione a catena. `false` se il suo registro è valido. - - `transactionIndex`: `QUANTITY` - numero intero della posizione dell'indice delle transazioni nel blocco. `null` quando il log è in sospeso. - - `transactionIndex`: `QUANTITY` - numero intero del registro della posizione dell'indice delle transazioni da cui è stato creato. `null` quando il log è in sospeso. - - `transactionHash`: `DATA`, 32 Bytes - hash delle transazioni da cui è stato creato il registro. `null` quando il log è in sospeso. - - `blockHash`: `DATA`, 32 byte - hash del blocco in cui si trovava questa transazione. `null` quando è in sospeso. `null` quando il log è in sospeso. - - `blockNumber`: `QUANTITY` il numero di blocco in cui si trovava questo registro. `null` quando è in sospeso. `null` quando il log è in sospeso. - - `address`: `DATI`, 20 Bytes - indirizzo da cui è nato questo registro. + - `removed`: `TAG` - `true` quando il registro è stato rimosso, a causa di una riorganizzazione della catena. `false` se il suo registro è valido. + - `transactionIndex`: `QUANTITY` - intero della posizione dell'indice della transazione nel blocco. `null` quando il registro è in sospeso. + - `transactionIndex`: `QUANTITY` - intero del registro della posizione dell'indice della transazione da cui è stato creato. `null` quando il registro è in sospeso. + - `transactionHash`: `DATA`, 32 Bytes - hash delle transazioni da cui è stato creato il registro. `null` quando il registro è in sospeso. + - `blockHash`: `DATA`, 32 byte - hash del blocco in cui si trovava questa transazione. `null` quando è in sospeso. `null` quando il registro è in sospeso. + - `blockNumber`: `QUANTITY` il numero di blocco in cui si trovava questo registro. `null` quando è in sospeso. `null` quando il registro è in sospeso. + - `address`: `DATA`, 20 Bytes - indirizzo da cui è stato originato questo registro. - `data`: `DATA` - contiene uno o più argomenti a 32 byte non indicizzati del registro. - - `topics`: `Array of DATA` - Array da 0 a 432 byte di `DATA` di argomenti di log indicizzati. (In _solidity_: il primo argomento è l'_hash_ della firma dell'evento (ad es. `Deposit(address,bytes32,uint256)`), tranne se hai dichiarato l'evento con lo specificatore `anonymous` + - `topics`: `Array of DATA` - Array da 0 a 432 byte di `DATA` di argomenti di registri indicizzati. (In _solidity_: il primo argomento è l'_hash_ della firma dell'evento (ad es. `Deposit(address,bytes32,uint256)`), tranne se hai dichiarato l'evento con lo specificatore `anonymous`.) - **Esempio** ```js @@ -1608,7 +1647,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":[ ### eth_getFilterLogs {#eth_getfilterlogs} -Restituisce un array di tutti i log corrispondenti al filtro con un dato ID. +Restituisce un array di tutti i registri corrispondenti al filtro con un dato ID. **Parametri** @@ -1633,17 +1672,17 @@ Risultato vedi [eth_getFilterChanges](#eth_getfilterchanges) ### eth_getLogs {#eth_getlogs} -Restituisce un array di tutti i log che corrispondono a un dato oggetto filtro. +Restituisce un array di tutti i registri che corrispondono a un dato oggetto filtro. **Parametri** 1. `Oggetto` - Le opzioni di filtro: -- `fromBlock`: `QUANTITY|TAG` - (opzionale, predefinito: `"latest"`) Numero intero del blocco, oppure `"latest"` per l'ultimo blocco minato oppure `"pending"`, `"earliest"` per le transazioni non ancora minate. -- `toBlock`: `QUANTITY|TAG` - (opzionale, predefinito: `"latest"`) numero intero del blocco, oppure `"latest"` per l'ultimo blocco minato, oppure `"pending"`, `"earliest"` per le transazioni non ancora minate. -- `address`: `DATA|Array`, 20 Bytes - (opzionale) Gli indirizzi del contratto oppure un elenco di indirizzi da cui dovrebbero avere origine i registri. -- `topics`: `Array of DATA`, - (opzionale) Array di argomenti `DATA` a 32 byte. Gli argomenti dipendono dall'ordine. Ogni argomento può anche essere una matrice di DATA con opzioni "oppure". -- `blockhash`: `DATI`, 32 Bytes - (opzionale, **future**) Con l'aggiunta di EIP-234, `blockHash` sarà una nuova opzione di filtro che limita i log restituiti al singolo blocco con l'hash `blockHash` da 32 byte. L'utilizzo di `blockHash` equivale a `fromBlock` = `toBlock` = il numero di blocco con hash `blockHash`. Se `blockHash` è presente nei criteri di filtraggio, non sono permessi né `fromBlock` né `toBlock`. +- `fromBlock`: `QUANTITY|TAG` - (facoltativo, predefinito: `"latest"`) Intero del numero di blocco, oppure `"latest"` per l'ultimo blocco minato oppure `"pending"`, `"earliest"` per le transazioni non ancora minate. +- `toBlock`: `QUANTITY|TAG` - (facoltativo, predefinito: `"latest"`) Intero del numero di blocco, oppure `"latest"` per l'ultimo blocco minato, oppure `"pending"`, `"earliest"` per le transazioni non ancora minate. +- `address`: `DATA|Array`, 20 Bytes - (facoltativo) Indirizzo del contratto oppure un elenco di indirizzi da cui dovrebbero avere origine i registri. +- `topics`: `Array of DATA`, - (facoltativo) Array di argomenti `DATA` a 32 byte. Gli argomenti dipendono dall'ordine. Ogni argomento può anche essere un array di DATI con opzioni "or". +- `blockhash`: `DATI`, 32 Bytes - (facoltativo, **future**) Con l'aggiunta di EIP-234, `blockHash` sarà una nuova opzione di filtro che limita i registra restituiti al singolo blocco con l'hash `blockHash` da 32 byte. L'utilizzo di `blockHash` equivale a `fromBlock` = `toBlock` = il numero di blocco con hash `blockHash`. Se `blockHash` è presente nei criteri di filtraggio, non sono permessi né `fromBlock` né `toBlock`. ```js params: [ @@ -1668,15 +1707,15 @@ Risultato vedi [eth_getFilterChanges](#eth_getfilterchanges) ### eth_getWork {#eth_getwork} -Restituisce l'hash del blocco corrente, il seedHash e la condizione limite da soddisfare ("target"). +Restituisce l'hash del blocco corrente, il seedHash e la condizione di confine da soddisfare ("target"). **Parametri** Nessuno **Restituisce** `Array` - Array con le seguenti proprietà: -1. `DATI`, 32 Byte - intestazione pow-hash del blocco corrente -2. `DATI`, 32 Byte - il seed hash utilizzato per il DAG. -3. `DATI`, 32 Byte - la condizione di confine ("target"), 2^256 / difficoltà. +1. `DATA`, 32 Byte - intestazione pow-hash del blocco corrente +2. `DATA`, 32 Byte - il seed hash utilizzato per il DAG. +3. `DATA`, 32 Byte - la condizione di confine ("target"), 2^256 / difficoltà. **Esempio** @@ -1775,7 +1814,7 @@ Memorizza una stringa nel database locale. params: ["testDB", "myKey", "myString"] ``` -**Restituisce** `Boolean` - `true` se il valore è stato memorizzato, in caso contrario `false`. +**Restituisce** `Boolean` - `true` se il valore è stato memorizzato, altrimenti `false`. **Esempio** @@ -1849,7 +1888,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"db_putHex","params":["testDB","m ### db_getHex (deprecated) {#db_gethex} -Memorizza i dati binari nel database locale. **Nota** questa funzione è superata. +Restituisce i dati binari del database locale. **Nota** questa funzione è superata. **Parametri** @@ -1860,7 +1899,7 @@ Memorizza i dati binari nel database locale. **Nota** questa funzione è superat params: ["testDB", "myKey"] ``` -**Restituisce** `DATI` - I dati precedentemente memorizzati. +**Restituisce** `DATA` - I dati precedentemente memorizzati. **Esempio** @@ -1908,10 +1947,10 @@ Invia un messaggio Whisper. 1. `Object` -Il contenuto dei post di Whisper: -- `da`: `DATA`, 60 Byte - (opzionale) L'identità del mittente. -- `to`: `DATA`, 60 Byte - (opzionale) L'identità del destinatario. Se presente, Whisper cifrerà il messaggio in modo che solo il destinatario possa decifrarlo. -- `topics`: `Array of DATA` - Array di argomenti `DATA`, affinchè il destinatario possa identificare i messaggi. -- `payload`: `DATA` - Il carico utile del messaggio. +- `da`: `DATA`, 60 Byte - (facoltativo) L'identità del mittente. +- `to`: `DATA`, 60 Byte - (facoltativo) L'identità del destinatario. Se presente, Whisper cifrerà il messaggio in modo che solo il destinatario possa decifrarlo. +- `topics`: `Array of DATA` - Array di argomenti `DATA`, affinché il destinatario possa identificare i messaggi. +- `payload`: `DATA` - Il payload del messaggio. - `priority`: `QUANTITY` - L'intero della priorità in un range da ... (?). - `ttl`: `QUANTITY` - intero del tempo residuo in secondi. @@ -1985,7 +2024,7 @@ params: [ ] ``` -**Restituisce** `Boolean` - restituisce `true` se il messaggio è stato inviato, altrimenti `false`. +**Restituisce** `Boolean` - restituisce `true` se il client detiene la chiave privata di tale identità, altrimenti `false`. **Esempio** @@ -2035,7 +2074,7 @@ params: [ ] ``` -**Restituisce** `Boolean` - restituisce `true` se l'identità è stata aggiunta con successo al gruppo, altrimenti `false`(?). +**Restituisce** `Boolean` - restituisce `true` se l'identità è stata aggiunta con successo al gruppo, altrimenti `false` (?). **Esempio** @@ -2058,8 +2097,8 @@ Crea un filtro per notificare, quando il client riceve un messaggio Whisper corr 1. `Oggetto` - Le opzioni del filtro: -- `to`: `DATA`, 60 Byte - (opzionale) L'identità del destinatario. _Quando è presente, proverà a decifrare qualsiasi messaggio in arrivo se il client detiene la chiave privata di questa identità._ -- `topics`: `Array of DATA` - Insieme di argomenti `DATA` a cui dovrebbero corrispondere gli argomenti del messaggio in entrata. You can use the following combinations: +- `to`: `DATA`, 60 Byte - (facoltativo) Identità del destinatario. _Quando è presente, proverà a decifrare qualsiasi messaggio in arrivo se il client detiene la chiave privata di questa identità._ +- `topics`: `Array of DATA` - Array di argomenti `DATA` a cui dovrebbero corrispondere gli argomenti del messaggio in entrata. Possono essere utilizzate le seguenti combinazioni: - `[A, B] = A && B` - `[A, [B, C]] = A && (B || C)` - `[null, A, B] = ANYTHING && A && B` `null` funge da jolly @@ -2091,7 +2130,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newFilter","params":[{"topic ### shh_uninstallFilter (deprecated){#shh_uninstallfilter} -Disinstalla un filtro con un ID specificato. Dovrebbe essere sempre chiamato quando l'orologio non è più necessario. Inoltre i filtri scadono quando non vengono richiesti con [shh_getFilterChange](#shh_getfilterchanges) per un periodo di tempo. **Nota** questa funzione è superata. +Disinstalla un filtro con un ID specificato. Dovrebbe essere sempre chiamato quando l'orologio non è più necessario. Inoltre, i filtri scadono quando non vengono richiesti con [shh_getFilterChange](#shh_getfilterchanges) per un periodo di tempo. **Nota** questa funzione è superata. **Parametri** @@ -2132,7 +2171,7 @@ params: [ ] ``` -**Restituisce** `Array` - Matrice di messaggi ricevuti dall'ultimo sondaggio: +**Restituisce** `Array` - Array di messaggi ricevuti dall'ultimo sondaggio: - `hash`: `DATA`, 32 Byte (?) - L'hash del messaggio. - `da`: `DATA`, 60 Byte - Il mittente del messaggio, se è stato specificato un mittente. @@ -2140,8 +2179,8 @@ params: [ - `expiry`: `QUANTITY` - Intero del tempo in secondi che esprime la scadenza presunta del messaggio (?). - `ttl`: `QUANTITY` - Intero del tempo durante il quale il messaggio dovrebbe fluttuare nel sistema, in secondi (?). - `sent`: `QUANTITY` - Intero della marca temporale unix quando il messaggio è stato inviato. -- `topics`: `Array of DATA` - Matrice di argomenti `DATA` contenuti nel messaggio. -- `payload`: `DATA` - Il carico utile del messaggio. +- `topics`: `Array of DATA` - Array di argomenti `DATA` contenuti nel messaggio. +- `payload`: `DATA` - Il payload del messaggio. - `workProved`: `QUANTITY` - Intero del lavoro richiesto da questo messaggio prima che fosse inviato (?). **Esempio** @@ -2201,7 +2240,7 @@ Risultato vedi [shh_getFilterChanges](#shh_getfilterchanges) Questa sezione include una dimostrazione di come distribuire un contratto utilizzando solo l'interfaccia RPC. Esistono vie alternative per la distribuzione di contratti in cui questa complessità viene eliminata tramite astrazione, ad esempio utilizzando librerie costruite partendo dall'interfaccia RPC, come [web3. s](https://web3js.readthedocs.io/) e [web3.py](https://github.com/ethereum/web3.py). Queste astrazioni sono generalmente più facili da capire e meno soggette a errori, ma è comunque utile capire cosa succede dietro le quinte. -Di seguito, trovi un semplice contratto intelligente, detto `Multiply7`, che sarà distribuito usando l'interfaccia JSON-RPC a un nodo di Ethereum. Questo tutorial presuppone che il lettore stia già eseguendo un nodo Geth. Maggiori informazioni sui nodi e sui client sono disponibili [qui](/developers/docs/nodes-and-clients/run-a-node). Fare riferimento alla documentazione del [client](/developers/docs/nodes-and-clients/) individuale per capire come avviare HTTP JSON-RPC per i client non-Geth. La maggior parte dei clienti serve di default su `localhost:8545`. +Di seguito, trovi un semplice contratto intelligente chiamato `Multiply7`, che sarà distribuito usando l'interfaccia JSON-RPC a un nodo di Ethereum. Questo tutorial presuppone che il lettore stia già eseguendo un nodo Geth. Maggiori informazioni sui nodi e sui client sono disponibili [qui](/developers/docs/nodes-and-clients/run-a-node). Fare riferimento alla documentazione del singolo [client](/developers/docs/nodes-and-clients/) per capire come avviare HTTP JSON-RPC per i client non-Geth. La maggior parte dei clienti serve di default su `localhost:8545`. ```javascript contract Multiply7 { @@ -2216,14 +2255,12 @@ contract Multiply7 { La prima cosa da fare è assicurarsi che l'interfaccia HTTP RPC sia abilitata. Questo significa che forniamo a Geth il flag `--http` all'avvio. In questo esempio usiamo il nodo Geth su una catena di sviluppo privata. Utilizzando questo approccio non abbiamo bisogno di ether sulla rete reale. ```bash - -geth --http --dev --mine --miner.threads 1 --unlock 0 console 2>>geth.log - +geth --http --dev console 2>>geth.log ``` Questo avvierà l'interfaccia HTTP RPC su `http://localhost:8545`. -Possiamo verificare che l'interfaccia sia in esecuzione recuperando l'indirizzo Coinbase e il saldo utilizzando [curl](https://curl.haxx.se/download.html). Si prega di notare che i dati in questi esempi saranno diversi sul nodo locale. Se vuoi provare questi comandi, sostituisci i parametri di richiesta nella seconda richiesta di Curl con il risultato restituito dalla prima. +Possiamo verificare che l'interfaccia sia in esecuzione recuperando l'indirizzo Coinbase e il saldo utilizzando [curl](https://curl.se). Si prega di notare che i dati in questi esempi saranno diversi sul nodo locale. Se vuoi provare questi comandi, sostituisci i parametri di richiesta nella seconda richiesta di curl con il risultato restituito dalla prima. ```bash curl --data '{"jsonrpc":"2.0","method":"eth_coinbase", "id":1}' -H "Content-Type: application/json" localhost:8545 @@ -2233,14 +2270,14 @@ curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635 {"id":2,"jsonrpc":"2.0","result":"0x1639e49bba16280000"} ``` -Poiché i numeri sono soggetti a codifica esadecimale, il saldo viene restituito in wei sotto forma di stringa esadecimale. Se vogliamo ottenere il saldo in Ether sotto forma di numero possiamo utilizzare web3 dalla console Geth. +Poiché i numeri sono soggetti a codifica esadecimale, il saldo viene restituito in wei sotto forma di stringa esadecimale. Se vogliamo ottenere il saldo in ether sotto forma di numero possiamo utilizzare web3 dalla console Geth. ```javascript web3.fromWei("0x1639e49bba16280000", "ether") // "410" ``` -Ora che vi sono Ether nella nostra catena di sviluppo privato, possiamo distribuire il contratto. Il primo passo è quello di compilare il contratto Multiply7 al codice di byte che può essere inviato all'EVM. Per installare solc, il compilatore Solidity, seguire la documentazione [Solidity](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Potresti voler utilizzare una versione `solc` più vecchia per abbinare [la versione del compilatore utilizzata per il nostro esempio](https://github.com/ethereum/solidity/releases/tag/v0.4.20).) +Ora che vi sono ether nella nostra catena di sviluppo privata, possiamo distribuire il contratto. Il primo passo è quello di compilare il contratto Multiply7 al codice di byte che può essere inviato all'EVM. Per installare solc, il compilatore Solidity, seguire la documentazione [Solidity](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Potresti voler utilizzare una versione `solc` più vecchia che corrisponda [ alla versione del compilatore utilizzata per il nostro esempio](https://github.com/ethereum/solidity/releases/tag/v0.4.20).) Il passo successivo è quello di compilare il contratto Multiply7 al codice di byte che può essere inviato all'EVM. @@ -2252,7 +2289,7 @@ Binary: 6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029 ``` -Ora che abbiamo il codice compilato, dobbiamo determinare quanto gas occorre per distribuirlo. L'interfaccia RPC ha un metodo `eth_estimateGas` che ci darà una stima. +Ora che abbiamo il codice compilato, dobbiamo determinare quanto carburante occorre per distribuirlo. L'interfaccia RPC ha un metodo `eth_estimateGas` che ci darà una stima. ```bash curl --data '{"jsonrpc":"2.0","method": "eth_estimateGas", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 5}' -H "Content-Type: application/json" localhost:8545 @@ -2266,22 +2303,22 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from {"id":6,"jsonrpc":"2.0","result":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"} ``` -La transazione è accettata dal nodo e viene restituito un hash di transazione. Questo hash può essere usato per tracciare la transazione. Il passo successivo è quello di determinare l'indirizzo dove il nostro contratto è distribuito. Ogni transazione eseguita creerà una ricevuta. Questa ricevuta contiene varie informazioni sulla transazione, ad esempio, in quale blocco è stata inclusa e quanto gas è stato usato dall'EVM. Se una transazione crea un contratto, conterrà anche l'indirizzo dello stesso. Possiamo recuperare la ricevuta con il metodo `eth_getTransactionReceipt` RPC. +La transazione è accettata dal nodo e viene restituito un hash di transazione. Questo hash può essere usato per tracciare la transazione. Il passo successivo è quello di determinare l'indirizzo dove il nostro contratto è distribuito. Ogni transazione eseguita creerà una ricevuta. Questa ricevuta contiene varie informazioni sulla transazione, ad esempio, in quale blocco è stata inclusa e quanto carburante è stato usato dall'EVM. Se una transazione crea un contratto, ne conterrà anche l'indirizzo. Possiamo recuperare la ricevuta con il metodo RPC `eth_getTransactionReceipt`. ```bash curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": ["0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"], "id": 7}' -H "Content-Type: application/json" localhost:8545 {"jsonrpc":"2.0","id":7,"result":{"blockHash":"0x77b1a4f6872b9066312de3744f60020cbd8102af68b1f6512a05b7619d527a4f","blockNumber":"0x1","contractAddress":"0x4d03d617d700cf81935d7f797f4e2ae719648262","cumulativeGasUsed":"0x1c31e","from":"0x9b1d35635cc34752ca54713bb99d38614f63c955","gasUsed":"0x1c31e","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","status":"0x1","to":null,"transactionHash":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf","transactionIndex":"0x0"}} ``` -Il nostro contratto è stato creato su `0x4d03d617d700cf81935d7f797f4e2ae719648262`. Un risultato nullo invece di una ricevuta significa che la transazione non è ancora stata inclusa in un blocco. Attendere un attimo e controllare se il miner è in esecuzione, quindi riprovare. +Il nostro contratto è stato creato su `0x4d03d617d700cf81935d7f797f4e2ae719648262`. Un risultato null invece di una ricevuta significa che la transazione non è ancora stata inclusa in un blocco. Attendere un attimo e controllare se il miner è in esecuzione, quindi riprovare. #### Interagire con i contratti intelligenti {#interacting-with-smart-contract} In questo esempio invieremo una transazione usando `eth_sendTransaction` al metodo `multiply` del contratto. -`eth_sendTransaction` richiede diversi argomenti, in particolare `from`, `to` e `data`. `From` è l'indirizzo pubblico del nostro conto, mentre `to` è l'indirizzo del contratto. L'argomento `data` contiene un carico utile che definisce quale metodo deve essere chiamato e con quali argomenti. È qui che entra in gioco l'[ABI (interfaccia binaria dell'applicazione)](https://docs.soliditylang.org/en/latest/abi-spec.html). L'ABI è un file JSON che determina come definire e codificare i dati per l'EVM. +`eth_sendTransaction` richiede diversi argomenti, in particolare `from`, `to` e `data`. `From` è l'indirizzo pubblico del nostro conto, mentre `to` è l'indirizzo del contratto. L'argomento `data` contiene un payload che definisce quale metodo deve essere chiamato e con quali argomenti. È qui che entra in gioco l'[ABI (interfaccia binaria dell'applicazione)](https://docs.soliditylang.org/en/latest/abi-spec.html). L'ABI è un file JSON che determina come definire e codificare i dati per l'EVM. -I byte del carico utile definiscono quale metodo viene chiamato nel contratto. Si tratta dei primi 4 byte dall'hash Keccak sul nome della funzione e sui suoi tipi di argomento, con codifica esadecimale. La funzione di moltiplicazione accetta un uint che è un alias per uint256. Ci ritroviamo quindi con: +I byte del payload definiscono quale metodo viene chiamato nel contratto. Si tratta dei primi 4 byte dall'hash Keccak sul nome della funzione e sui suoi tipi di argomento, con codifica esadecimale. La funzione di moltiplicazione accetta un uint che è un alias per uint256. Ci ritroviamo quindi con: ```javascript web3.sha3("multiply(uint256)").substring(0, 10) @@ -2327,7 +2364,7 @@ Dall'invio di una transazione, è stato restituito un hash di transazione. Recup } ``` -La ricevuta contiene un log. Questo log è stato generato da EVM sull'esecuzione della transazione e incluso nella ricevuta. La funzione `moltiplica` mostra che l'evento `Print` è stato alzato con i tempi di input 7. Poiché l'argomento per l'evento `Print` era un uint256, possiamo decodificare secondo le regole ABI, ottenendo così il decimale 42 previsto. Oltre ai dati, vale la pena notare che gli argomenti possono essere utilizzati per determinare quale evento ha creato il registro: +La ricevuta contiene un registro. Questo registro è stato generato da EVM sull'esecuzione della transazione e incluso nella ricevuta. La funzione `moltiplica` mostra che l'evento `Print` è stato alzato con i tempi di input 7. Poiché l'argomento per l'evento `Print` era un uint256, possiamo decodificare secondo le regole ABI, ottenendo così il decimale 42 previsto. Oltre ai dati, vale la pena notare che gli argomenti possono essere utilizzati per determinare quale evento ha creato il registro: ```javascript web3.sha3("Print(uint256)") @@ -2339,7 +2376,7 @@ Questa è stata solo una breve introduzione su alcuni dei compiti più comuni, d ## Argomenti correlati {#related-topics} - [Specifiche di JSON-RPC](http://www.jsonrpc.org/specification) -- [Nodi e client](/developers/docs/nodes-and-clients/) -- [API per JavaScript](/developers/docs/apis/javascript/) -- [API per il backend](/developers/docs/apis/backend/) +- [ Nodi e client](/developers/docs/nodes-and-clients/) +- [API JavaScript](/developers/docs/apis/javascript/) +- [API backend](/developers/docs/apis/backend/) - [Client di esecuzione](/developers/docs/nodes-and-clients/#execution-clients) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/index.md index 78cf705db84..d69d912bb92 100644 --- a/src/content/translations/it/developers/docs/consensus-mechanisms/index.md +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/index.md @@ -36,7 +36,7 @@ Come Bitcoin, Ethereum in precedenza utilizzava un protocollo di consenso basato #### Creazione di blocchi {#pow-block-creation} -I validatori creano i blocchi. Per ogni slot viene selezionato casualmente un validatore che funge da propositore di blocchi. Il client di consenso dei validatori richiede un pacchetto di transazioni come 'payload di esecuzione' dal client di esecuzione associato. Questo viene avvolto in dati di consenso per formare un blocco, che viene inviato ad altri nodi sulla rete Ethereum. La produzione di questo blocco è ricompensata in ETH. Nei rari casi in cui esistono diversi blocchi possibili per un singolo slot, o in cui i nodi vengono a conoscenza dei blocchi in momenti diversi, l'algoritmo di scelta della diramazione seleziona il blocco che forma la catena con il maggiore peso di attestazioni (dove il peso è il numero di validatori che attestano, scalato per il loro saldo di ETH). +I miner competono per creare nuovi blocchi, riempiti di transazioni elaborate. Il vincitore condivide il nuovo blocco con il resto della rete e guadagna ETH appena coniati. La gara è vinta dal computer che è capace di risolvere più velocemente un rompicapo matematico. Ciò produce il collegamento crittografico tra il blocco corrente e quello precedente. Risolvere questo rompicapo rappresenta il lavoro da svolgere nel modello "proof-of-work". La catena canonica è quindi determinata da una regola di scelta della biforcazione, che seleziona la serie di blocchi che ha richiesto il maggiore lavoro per essere minata. #### Sicurezza {#pow-security} @@ -50,7 +50,7 @@ Ora Ethereum utilizza un protocollo di consenso basato sul **Proof of Stake (PoS #### Creazione di blocchi {#pos-block-creation} -Il Proof of Stake è reso possibile da validatori che fanno staking con i propri ETH per prendere parte al sistema. Un validatore è scelto a caso per creare nuovi blocchi, condividerli con la rete e guadagnare ricompense. Anziché svolgere un intenso lavoro di calcolo, è sufficiente fare staking con gli ETH nella rete. Questo aspetto è ciò che incentiva un comportamento sano della rete. +I validatori creano i blocchi. Per ogni slot viene selezionato casualmente un validatore che funge da propositore di blocchi. Il client di consenso dei validatori richiede un pacchetto di transazioni come 'payload di esecuzione' dal client di esecuzione associato. Questo viene avvolto in dati di consenso per formare un blocco, che viene inviato ad altri nodi sulla rete Ethereum. La produzione di questo blocco è ricompensata in ETH. Nei rari casi in cui esistono diversi blocchi possibili per un singolo slot, o in cui i nodi vengono a conoscenza dei blocchi in momenti diversi, l'algoritmo di scelta della diramazione seleziona il blocco che forma la catena con il maggiore peso di attestazioni (dove il peso è il numero di validatori che attestano, scalato per il loro saldo di ETH). #### Sicurezza {#pos-security} diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md new file mode 100644 index 00000000000..1e1fa8726a0 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md @@ -0,0 +1,163 @@ +--- +title: Attacco e difesa del proof-of-stake di Ethereum +description: Scopri di più sui vettori di attacco noti sul proof-of-stake di Ethereum e come sono difesi. +lang: it +--- + +Ladri e sabotatori sono costantemente alla ricerca di opportunità per attaccare i software dei client di Ethereum. Questa pagina delinea i vettori di attacco noti sul livello di consenso di Ethereum, definendo come possono essere difesi. Le informazioni su questa pagina sono adattate da una [versione più lunga](https://mirror.xyz/jmcook.eth/YqHargbVWVNRQqQpVpzrqEQ8IqwNUJDIpwRP7SS5FXs). + +## Prerequisiti {#prerequisites} + +È necessario avere delle conoscenze di base del [proof-of-stake](/developers/docs/consensus-mechanisms/pos/). Inoltre, sarebbe utile avere una comprensione di base del [livello d'incentivazione](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties) di Ethereum e dell'algoritmo di scelta della diramazione, [LMD-GHOST](/developers/docs/consensus-mechanisms/pos/gasper). + +## Cosa vogliono gli utenti malevoli? {#what-do-attackers-want} + +Spesso si crede erroneamente che un utente malevolo di successo possa generare altro ether, o drenarlo da conti arbitrari. Nessuna delle due cose è possibile, poiché tutte le transazioni sono eseguite da tutti i client di esecuzione sulla rete. Devono soddisfare delle condizioni di validità di base (es. le transazioni sono firmate dalla chiave privata del mittente, il mittente ha un saldo sufficiente, ecc.), altrimenti sono semplicemente annullate. Esistono tre classi di risultati che un utente malevolo potrebbe realisticamente ottenere: riorganizzazioni, doppia finalità o ritardo della finalità. + +Una **"riorganizzazione"** è un rimescolamento dei blocchi in un nuovo ordine, magari con l'aggiunta o la sottrazione di blocchi nella catena canonica. Una riorganizzazione malevola potrebbe assicurare l'inclusione o esclusione di blocchi specifici, consentendo la doppia spesa o l'estrazione di valore da transazioni di front-running e back-running (MEV). Le riorganizzazioni, inoltre, potrebbero essere utilizzate per impedire l'inclusione di certe transazioni nella catena canonica: una forma di censura. La forma più estrema di riorganizzazione è detta "inversione di finalità", che rimuove o sostituisce dei blocchi precedentemente finalizzati. Questa è possibile soltanto se più di ⅓ dell'ether in staking totale è distrutto dall'utente malevolo; questa garanzia è nota come "finalità economica" – maggiori informazioni al riguardo sono riportate in seguito. + +La **doppia finalità** è l'improbabile ma grave condizione in cui due diramazioni riescono a finalizzarsi simultaneamente, creando uno scisma permanente nella catena. Ciò è teoricamente possibile per un utente malevolo disposto a rischiare il 34% dell'ether in staking totale. La community sarebbe obbligata a coordinarsi all'esterno della catena e accordarsi su quale catena seguire, il che richiederebbe forza al livello sociale. + +Un attacco di **ritardo di finalità** impedisce alla rete di raggiungere le condizioni necessarie per finalizzare le sezioni della catena. Senza finalità, è difficile fidarsi delle applicazioni finanziarie basate su Ethereum. L'obiettivo di un attacco di ritardo di finalità è, probabilmente, semplicemente quello di interrompere Ethereum piuttosto che di trarne direttamente profitto, a meno che l'utente malevolo non abbia qualche posizione breve strategica. + +Un attacco al livello sociale potrebbe mirare a minare la fiducia pubblica in Ethereum, svalutare l'ether, ridurne l'adozione o indebolire la community di Ethereum per complicare la coordinazione fuori banda. + +Avendo stabilito perché un avversario potrebbe attaccare Ethereum, le seguenti sezioni esaminano _come_ potrebbe farlo. + +## Metodi di attacco {#methods-of-attack} + +### Attacchi al livello 0 {#layer-0} + +Prima di tutto, gli individui che non partecipano attivamente a Ethereum (eseguendo un software del client), possono attaccarlo prendendo di mira il livello sociale (Livello 0). Il Livello 0 è la base su cui è costruito Ethereum e, come tale, rappresenta una potenziale superficie per gli attacchi, con conseguenze che si propagano sul resto dello stack. Alcuni esempi potrebbero includere: + +- Una campagna di disinformazione potrebbe erodere la fiducia della community nella tabella di marcia di Ethereum, nei team di sviluppatori, nelle app, ecc. Questo potrebbe quindi ridurre il numero di persone desiderose di partecipare alla protezione della rete, penalizzando sia la decentralizzazione che la sicurezza cripto-economica. +- Attacchi mirati e/o intimidazioni dirette alla community degli sviluppatori. Questo potrebbe indurre all'uscita volontaria degli sviluppatori e rallentare il progresso di Ethereum. + +- Anche una regolamentazione troppo zelante potrebbe essere considerata un attacco al Livello 0, poiché potrebbe disincentivare rapidamente la partecipazione e l'adozione. +- L'infiltrazione di utenti esperti ma malevoli nella community di sviluppatori il cui obiettivo è rallentare il progresso con discussioni futili, ritardare le decisioni fondamentali, creare spam, ecc. +- Tangenti agli attori principali nell'ecosistema di Ethereum per influenzare il processo decisionale. + +Ciò che rende particolarmente pericolosi questi attacchi è che in molti casi è necessario disporre di pochissimo capitale o conoscenze tecniche. Un attacco al Livello 0 potrebbe essere un moltiplicatore di un attacco cripto-economico. Ad esempio, se la censura o l'inversione della finalità fossero ottenute da uno stakeholder attivo di maggioranza, minare il livello sociale potrebbe complicare la coordinazione di una risposta fuori banda della community. + +Difendersi dagli attacchi di Livello 0 probabilmente non è semplice, ma possono essere stabiliti dei principi fondamentali. Uno di questi è mantenere un rapporto complessivamente elevato tra segnale e rumore per le informazioni pubbliche su Ethereum, create e diffuse da membri onesti della community tramite blog, server Discord, specifiche annotate, libri, podcast e YouTube. Qui su ethereum.org cerchiamo di mantenere informazioni accurate e di tradurle in quante più lingue possibili. Inondare uno spazio di informazioni di alta qualità e meme è una difesa efficiente contro la disinformazione. + +Un'altra fortificazione importante contro gli attacchi al livello sociale è una chiara dichiarazione di missione e un chiaro protocollo di governance. Ethereum si è posizionato come il campione di decentralizzazione e sicurezza tra i livelli 1 dei contratti intelligenti, dando anche un elevato valore a scalabilità e sostenibilità. A prescindere dall'insorgere di divergenze nella community di Ethereum, questi principi essenziali sono minimamente compromessi. Valutare una narrativa basata su tali principi essenziali ed esaminarli tramite tranche successive di revisioni nel processo di EIP (proposta di miglioramento di Ethereum) potrebbe aiutare la community a distinguere gli utenti buoni da quelli "cattivi" e a limitare l'ambito di influenza degli utenti malevoli nella direzione futura di Ethereum. + +Infine, è fondamentale che la community di Ethereum resti aperta e accogliente per tutti i partecipanti. Una community con guardiani ed esclusività è una community specialmente vulnerabile agli attacchi sociali, poiché è facile costruire narrative "noi e loro". Il tribalismo e il massimalismo tossico feriscono la community ed erodono la sicurezza del Livello 0. Gli utenti di Ethereum con un interesse acquisito nella sicurezza della rete dovrebbero vedere la propria condotta online e nel mondo reale come un contributo diretto alla sicurezza del Livello 0 di Ethereum. + +### Attaccare il protocollo {#attacking-the-protocol} + +Chiunque può eseguire un software del client di Ethereum. Per aggiungere un validatore a un client, un utente deve mettere 32 ether in staking nel contratto di deposito. Un validatore consente a un utente di partecipare attivamente alla sicurezza della rete di Ethereum proponendo e attestando nuovi blocchi. Il validatore ora ha una voce che può usare per influenzare i contenuti futuri della blockchain; può farlo onestamente, accrescendo i propri ether tramite le ricompense, o può provare a manipolare il processo a proprio vantaggio, rischiando il proprio stake. Un metodo per generare un attacco è accumulare una quota maggiore dello stake totale e utilizzarla per superare i voti dei validatori onesti. Maggiore è la quota dello stake controllata dall'utente malevolo, maggiore è il suo potere di voto, specialmente in determinati traguardi economici che esploreremo in seguito. Tuttavia, gran parte degli utenti malevoli non riuscirà ad accumulare abbastanza ether per attaccare in questo modo, quindi dovrà invece utilizzare delle tecniche per manipolare la maggioranza onesta perché agisca in un certo modo. + +Fondamentalmente, tutti gli attacchi con pochi ether in staking sono lievi variazioni di due tipi di comportamenti scorretti dei validatori: ipoattività (mancata attivazione/proposta o farlo in ritardo) o iperattività (proporre/attestare troppe volte in uno slot). Nelle loro forme più basilari, queste azioni sono gestite facilmente dall'algoritmo di scelta della diramazione e dal livello d'incentivazione, ma esistono metodi più intelligenti per imbrogliare il sistema a vantaggio dell'utente malevolo. + +### Attacchi con piccoli importi di ETH {#attacks-by-small-stakeholders} + +#### riorganizzazioni {#reorgs} + +Svariati documenti hanno spiegato gli attacchi a Ethereum che ottengono riorganizzazioni o ritardi di finalità con soltanto una piccola quota dell'ether in staking totale. Questi, generalmente, si affidano al fatto che l'utente malevolo trattenga alcune informazioni da altri validatori per poi rilasciarle in modo sfumato e/o in un momento opportuno. Solitamente mirano a spostare alcuni blocchi onesti dalla catena canonica. [Neuder et al 2020](https://arxiv.org/pdf/2102.02247.pdf), hanno mostrato come un validatore malevolo possa creare e attestare un blocco (`B`) per uno slot specifico `n+1` ma evitare di propagarlo ad altri nodi sulla rete. Invece, si attiene a quel blocco attestato fino allo slot successivo `n+2`. Un validatore onesto propone un blocco (`C`) per lo slot `n+2`. Quasi simultaneamente, l'utente malevolo può rilasciare il proprio blocco trattenuto (`B`) e le attestazioni trattenute per esso, oltre ad attestare `B` come testa della catena con i propri voti per lo slot `n+2`, negando di fatto l'esistenza del blocco onesto `C`. Quando il blocco onesto `D` viene rilasciato, l'algoritmo di scelta della diramazione vede la costruzione di `D` in cima a `B` come più pesante della costruzione di `D` in cima a `C`. L'utente malevolo, dunque, è riuscito a rimuovere il blocco onesto `C` nello slot `n+2` dalla catena canonica utilizzando una riorganizzazione a priori di 1 blocco. [Un utente malevolo con il 34%](https://www.youtube.com/watch?v=6vzXwwk12ZE) dello stake ha ottime probabilità di riuscire nel suo attacco, come spiegato [in questa nota](https://notes.ethereum.org/plgVdz-ORe-fGjK06BZ_3A#Fork-choice-by-block-slot-pair). In teoria, però, questo attacco potrebbe essere tentato con stake inferiori. [Neuder et al 2020](https://arxiv.org/pdf/2102.02247.pdf) hanno descritto che questo attacco funziona con uno stake del 30%, ma è stato in seguito dimostrato come fattibile con il [2% dello stake totale](https://arxiv.org/pdf/2009.04987.pdf) e poi, ancora, per un [singolo validatore](https://arxiv.org/abs/2110.10086#) che utilizza le tecniche di bilanciamento che esamineremo nella prossima sezione. + +![riorganizzazione a priori](reorg-schematic.png) + +Un diagramma concettuale dell'attacco di riorganizzazione di un blocco descritto sopra (adattato da https://notes.ethereum.org/plgVdz-ORe-fGjK06BZ_3A#Fork-choice-by-block-slot-pair) + +Un attacco più sofisticato può dividere l'insieme di validatori onesti in gruppi discreti aventi visioni diverse della testa della catena. Ciò è noto come **attacco di bilanciamento**. L'utente malevolo attende la propria possibilità di proporre un blocco e, quando arriva, tergiversa e ne propone due. Invia un blocco a metà dell'insieme dei validatori onesti e l'altro blocco all'altra metà. L'equivoco sarebbe rilevato dall'algoritmo di scelta della diramazione e il propositore di blocchi riceverebbe un taglio e sarebbe espulso dalla rete, ma i due blocchi continuerebbero a esistere e avrebbe circa metà dell'insieme dei validatori ad attestarlo per ogni diramazione. Nel mentre, i validatori malevoli rimanenti trattengono le proprie attestazioni. Quindi, rilasciando selettivamente le attestazioni a favore dell'una o dell'altra diramazione al numero sufficiente di validatori, proprio come eseguito dall'algoritmo di scelta della diramazione, portano il peso accumulato delle attestazioni a favore di una o dell'altra diramazione. Questo può continuare per sempre, con i validatori malevoli che mantengono una divisione equa dei validatori tra le due diramazioni. Poiché nessuna delle due diramazioni può attrarre una supermaggioranza dei 2/3, la Beacon Chain non si finalizzerebbe. + +Gli **attacchi di rimbalzo** sono simili. Anche in questo caso i voti sono trattenuti dai validatori malevoli. Invece di rilasciarli per mantenere una divisione equa tra le due diramazioni, utilizzano i propri voti nei momenti opportuni per giustificare punti di controllo che si alternano tra la diramazione A e la diramazione B. Questo tira e molla di giustificazioni tra le due diramazioni impedisce la presenza di coppie di punti di controllo di origine e di destinazione giustificati finalizzabili su una delle due catene, interrompendo la finalità. + + + +Sia gli attacchi di rimbalzo che quelli di bilanciamento si basano sul fatto che l'utente malevolo abbia un controllo molto preciso sulle tempistiche dei messaggi attraverso la rete, il che è improbabile. Tuttavia, le difese sono integrate nel protocollo sotto forma di ponderazione aggiuntiva data ai messaggi immediati rispetto a quelli lenti. Ciò è noto come [incremento del peso del propositore](https://github.com/ethereum/consensus-specs/pull/2730). Per difendersi dagli attacchi di rimbalzo, l'algoritmo di scelta della diramazione è stato aggiornato così che l'ultimo punto di controllo giustificato possa passare a quello di una catena alternativa soltanto durante il [primo 1/3 degli slot in ogni epoca](https://ethresear.ch/t/prevention-of-bouncing-attack-on-ffg/6114). Questa condizione impedisce all'utente malevolo di risparmiare voti da distribuire in seguito: l'algoritmo di scelta della diramazione, semplicemente, resta leale al punto di controllo che ha scelto nel primo 1/3 dell'epoca in cui avrebbero votato i validatori più onesti. + +Combinate, queste misure creano uno scenario in cui un propositore di blocchi onesto emette il proprio blocco molto rapidamente dopo l'inizio dello slot, poi c'è un periodo di circa 1/3 di slot (4 secondi) in cui quel nuovo blocco potrebbe causare il passaggio dell'algoritmo di scelta della diramazione a un'altra catena. Dopo quella stessa scadenza, le attestazioni che arrivano dai validatori lenti sono deponderate rispetto a quelle arrivate prima. Ciò favorisce fortemente i propositori e validatori rapidi nel determinare la testa della catena, riducendo sostanzialmente la probabilità di riuscita di un attacco di bilanciamento o di rimbalzo. + +Vale la pena notare che il solo potenziamento del propositore difende solo dalle "riorganizzazioni convenienti", cioè quelle tentate da un utente malevolo con uno stake ridotto. Difatti, lo stesso potenziamento del propositore è raggirabile dai detentori di stake maggiori. Gli autori di [questo post](https://ethresear.ch/t/change-fork-choice-rule-to-mitigate-balancing-and-reorging-attacks/11127) descrivono come un utente malevolo con il 7% dello stake possa distribuire i propri voti strategicamente per indurre i validatori onesti a costruire sulla sua diramazione, riorganizzando un blocco onesto. Questo attacco è stato concepito supponendo condizioni di latenza ideali, che sono molto improbabili. Le probabilità sono ancora fortemente a sfavore dell'utente malevolo, e lo stake maggiore comporta anche un maggiore capitale a rischio e un disincentivo economico persino più forte. + +È stato proposto anche un [attacco di bilanciamento specificamente mirato alla regola LMD](https://ethresear.ch/t/balancing-attack-lmd-edition/11853), suggerito come fattibile nonostante il potenziamento del propositore. Un utente malevolo configura due catene in competizione, equivocando la proposta di blocchi e propagando ogni blocco a circa metà della rete, configurando un saldo approssimativo tra le due diramazioni. Quindi, i validatori complici equivocano i propri voti, fissando tempistiche tali che metà della rete riceva prima i loro voti per la diramazione `A` e l'altra metà riceva prima i loro voti per la diramazione `B`. Poiché la regola LMD scarta la seconda attestazione e mantiene soltanto la prima per ogni validatore, metà della rete visualizza i voti per `A` e nessun voto per `B`, l'altra metà vede i voti per `B` e nessun voto per `A`. Gli autori descrivono la regola LMD come dare all'avversario "notevole potere" per effettuare un attacco di bilanciamento. + +Questo vettore di attacco LMD è stato chiuso [aggiornando l'algoritmo di scelta della diramazione](https://github.com/ethereum/consensus-specs/pull/2845) in modo che scarti del tutto i validatori equivoci dalla considerazione della scelta della diramazione. L'algoritmo di scelta della diramazione, inoltre, ignorerà l'influenza futura dei validatori equivoci. Ciò impedisce l'attacco di bilanciamento delineato sopra, mantenendo la resilienza contro attacchi valanga. + +Un'altra classe di attacchi, detta [**attacchi valanga**](https://ethresear.ch/t/avalanche-attack-on-proof-of-stake-ghost/11854/3), è stata descritta in un [documento di marzo 2022](https://arxiv.org/pdf/2203.01315.pdf). Per causarlo, l'utente malevolo deve controllare diversi propositori di blocchi consecutivi. In ognuno degli slot di proposta del blocco, l'utente malevolo trattiene il proprio blocco, raccogliendoli finché la catena onesta non raggiunge un peso dell'albero secondario equivalente ai blocchi trattenuti. Poi, i blocchi trattenuti vengono rilasciati così che equivochino al massimo. Gli autori suggeriscono che il potenziamento del propositore – la prima difesa contro gli attacchi di bilanciamento e di rimbalzo – non protegge da alcune varianti dell'attacco valanga. Tuttavia, gli autori hanno anche dimostrato l'attacco soltanto su una versione altamente idealizzata dell'algoritmo di scelta della diramazione (hanno utilizzato GHOST senza LMD). + +L'attacco valanga è mitigato dalla porzione LMD dell'algoritmo di scelta della diramazione LMD-GHOST. LMD sta per "guidato dall'ultimo messaggio" e si riferisce a una tabella tenuta da ogni validatore, contenente l'ultimo messaggio ricevuto dagli altri validatori. Quel campo viene aggiornato soltanto se il nuovo messaggio proviene da uno slot successivo a quello già nella tabella per uno specifico validatore. In pratica, ciò significa che in ogni slot, il primo messaggio ricevuto è quello che ha accettato e qualsiasi altro messaggio è un equivoco da ignorare. In altre parole, i client di consenso non contano gli equivoci – utilizzano il primo messaggio in arrivo da ogni validatore e gli equivoci sono semplicemente scartati, impedendo gli attacchi valanga. + +Esistono diversi altri potenziali aggiornamenti futuri alla regola di scelta della diramazione che potrebbero sommarsi alla sicurezza fornita dal potenziamento del propositore. Uno è [view-merge](https://ethresear.ch/t/view-merge-as-a-replacement-for-proposer-boost/13739), dove gli attestatori congelano la propria vista della scelta della diramazione `n` secondi prima dell'inizio di uno slot e il propositore di blocchi quindi aiuta a sincronizzare la vista della catena nella rete. Un altro aggiornamento potenziale è la [finalità del singolo slot](https://notes.ethereum.org/@vbuterin/single_slot_finality), che protegge dagli attacchi basati sulla tempistica del messaggio finalizzando la catena dopo un solo slot. + +#### Ritardo della finalità {#finality-delay} + +[Lo stesso documento](https://econcs.pku.edu.cn/wine2020/wine2020/Workshop/GTiB20_paper_8.pdf) che prima descriveva l'attacco di riorganizzazione del blocco singolo a basso costo, descriveva anche un attacco di ritardo di finalità (anche noto come "perdita di vitalità"), che si basa sul fatto che 'utente malevolo proponga il blocco per un blocco di confine dell'epoca. Questo è fondamentale perché questi blocchi di confine dell'epoca diventano i punti di controllo che Casper FFG utilizza per finalizzare porzioni della catena. L'utente malevolo, semplicemente, trattiene il blocco finché abbastanza validatori onesti non utilizzano i propri voti FFC a favore del precedente blocco di confine dell'epoca come destinazione di finalizzazione corrente. Quindi, rilasciano il blocco trattenuto. Attestano al proprio blocco, così come i validatori onesti rimanenti, creando diramazioni con punti di controllo di destinazione differenti. Se hanno tempistiche corrette, impediranno la finalità perché non ci sarà una supermaggioranza dei 2/3 che attesti a entrambe le diramazioni. Minore è lo stake, più precisa deve essere la tempistica, poiché l'utente malevolo controlla meno attestazioni direttamente, e minori sono le probabilità che l'utente malevolo controlli il validatore che propone un dato di confine dell'epoca. + +#### Attacchi a lungo raggio {#long-range-attacks} + +Esiste inoltre una classe di attacco specifica delle blockchain di proof-of-stake che comporta che un validatore che ha partecipato al blocco di genesi mantenga una diramazione separata della blockchain insieme a quella onesta, convincendo infine l'insieme di validatori onesti a passare ad essa in un dato momento opportuno molto successivo. Questo tipo di attacco non è possibile su Ethereum per via del dispositivo di finalità che assicura che tutti i validatori concordino sullo stato della catena onesta a intervalli regolari ("punti di controllo"). Questo semplice meccanismo neutralizza gli attacchi a lungo raggio, poiché i client di Ethereum semplicemente non riorganizzeranno i blocchi finalizzati. I nuovi nodi che si uniscono alla rete lo fanno trovando un hash di stato recente fidato (un "[punto di controllo a soggettività debole](https://blog.ethereum.org/2014/11/25/proof-stake-learned-love-weak-subjectivity/)") e utilizzandolo come un blocco di pseudo-genesi su cui costruire. Questo crea una 'porta di fiducia' per un nuovo nodo che accede alla rete prima che possa iniziare a verificare le informazioni da solo. + +#### Denial of Service {#denial-of-service} + +Il meccanismo di PoS di Ethereum seleziona un unico validatore dall'insieme di validatori totali perché sia un propositore di blocchi in ogni slot. Questo è calcolabile utilizzando una funzione pubblicamente nota ed è possibile, per un avversario, identificare il propositore di blocco successivo lievemente in anticipo rispetto alla sua proposta del blocco. Poi, l'utente malevolo può spammare il propositore del blocco per impedirgli di scambiare le informazioni con i suoi pari. Al resto della rete sembrerà che il propositore del blocco sia offline e lo slot resterà semplicemente vuoto. Questo potrebbe essere una forma di censura contro validatori specifici, che impedisce loro di aggiungere informazioni alla blockchain. L'implementazione di elezioni segrete di un singolo capo (SSLE) o di elezioni segrete di un capo non singolo mitigheranno i rischi di DoS, poiché soltanto il propositore del blocco potrà sapere di essere stato selezionato e la selezione non è nota in anticipo. Ciò non è ancora implementato, ma è un'area attiva di [ricerca e sviluppo](https://ethresear.ch/t/secret-non-single-leader-election/11789). + +Tutto questo punta al fatto che sia davvero difficile attaccare Ethereum con successo con uno stake ridotto. Gli attacchi fattibili qui descritti richiedono un algoritmo di scelta della diramazione idealizzato, condizioni di rete improbabili, oppure i vettori d'attacco sono già stati chiusi con correzioni relativamente minori al software del client. Questo, ovviamente, non esclude la possibilità che si verifichino zero day, ma dimostra la barra estremamente elevata di capacità tecnica, conoscenza del livello di consenso e fortuna necessaria perché un utente malevolo con uno stake di minoranza sia efficace. Dalla prospettiva di un utente malevolo, la cosa migliore dare sarebbe accumulare quanto più ether possibile e tornare armato di una maggiore quota dello stake totale. + +### Utenti malevoli che utilizzano il >= 33% dello stake totale {#attackers-with-33-stake} + +Tutti gli attacchi menzionati precedentemente in questo articolo raggiungono una maggiore probabilità di riuscita quando l'utente malevolo ha più ether in staking con cui votare, e più validatori che potrebbero essere scelti per proporre i blocchi in ogni slot. Un validatore malevolo potrebbe dunque mirare a controllare quanto più ether possibile. + +Il 33% dell'ether in staking è un punto di riferimento per un utente malevolo poiché, con un qualsiasi importo maggiore, può impedire la finalizzazione della catena senza dover controllare finemente le azioni degli altri validatori. Possono semplicemente scomparire insieme. Se 1/3 o più dell'ether in staking attesta malevolmente o non riesce ad attestare, allora non può esistere una supermaggioranza dei 2/3 e la catena non può finalizzare. La difesa in questo caso è la perdita per inattività. La perdita per inattività identifica quei validatori che non attestano o che attestano il contrario della maggioranza. L'ether in staking posseduto da tali validatori non attestanti è gradualmente disperso finché non rappresenteranno collettivamente meno di 1/3 del totale, così che la catena possa nuovamente finalizzare. + +Lo scopo della perdita per inattività è far nuovamente finalizzare la catena. Tuttavia, l'utente malevolo perde anche una porzione del proprio ether in staking. L'inattività persistente tra validatori che rappresentano il 33% dell'ether in staking totale è molto costosa anche se i validatori non ricevono un taglio. + +Supponendo che la rete di Ethereum sia asincrona (cioè, ci siano ritardi tra i messaggi inviati e ricevuti), un utente malevolo che controlla il 34% dello stake totale potrebbe causare una doppia finalità. Ciò è dovuto al fatto che l'utente malevolo può equivocare quando è scelto come propositore di blocchi, poi votare due volte con tutti i suoi validatori. Questo crea una situazione in cui esiste una diramazione della blockchain, ciascuna votata dal 34% dell'ether in staking. Ogni diramazione richiede soltanto il 50% dei voti dei validatori rimanenti per entrambe le diramazioni per essere supportata da una supermaggioranza, nel qual caso entrambe le catene possono finalizzarsi (poiché il 34% dei validatori malevoli + metà dei rimanenti 66% = 67% su ogni diramazione). Ogni blocco concorrente dovrebbe essere ricevuto all'incirca dal 50% dei validatori onesti, quindi questo attacco è fattibile soltanto quando l'utente malevolo ha un certo grado di controllo sulla tempistica dei messaggi che si propagano per la rete così da poter ingannare metà dei validatori onesti su ogni catena. L'utente malevolo dovrebbe necessariamente distruggere integralmente il proprio stake (34% di circa 10 milioni di ether con l'insieme odierno di validatori) per ottenere tale doppia finalità, poiché il 34% dei validatori voterebbe due volte simultaneamente – un'infrazione punibile con la sanzione di correlazione massima. La difesa contro questo attacco è il costo molto elevato della distruzione del 34% dell'ether in staking totale. Riprendersi da tale attacco richiederebbe alla community di Ethereum di coordinarsi "fuori banda" e di accordarsi sul seguire una delle due diramazioni ignorando l'altra. + +### Utenti malevoli che utilizzano circa il 50% dello stake totale {#attackers-with-50-stake} + +Al 50% dell'ether in staking, un gruppo malevolo di validatori potrebbe teoricamente dividere la catena in due diramazioni di pari dimensioni e quindi semplicemente utilizzare tutto il proprio 50% dello stake per votare contrariamente all'insieme di validatori onesti, mantenendo così le due diramazioni e impedendo la finalità. La perdita per inattività su entrambe le diramazioni condurrebbe infine alla finalizzazione di entrambe le catene. A questo punto, l'unica opzione è fare affidamento su un recupero sociale. + +È molto improbabile che un gruppo avversario di validatori possa controllare coerentemente e precisamente il 50% dello stake totale, dato il livello di flusso di numeri di validatori onesti, la latenza di rete, ecc.; il costo elevato di effettuare un simile attacco, insieme alla bassa probabilità di successo, sembra essere un forte disincentivo per un utente malevolo razionale, specialmente se un piccolo investimento aggiuntivo per ottenere _oltre il_ 50% sblocca molto più potere. + +Al >50% dello stake totale, l'utente malevolo potrebbe dominare l'algoritmo di scelta della diramazione. In questo caso sarebbe in grado di attestare con il voto di maggioranza, ottenendo controllo sufficiente per effettuare brevi riorganizzazioni senza dover ingannare i client onesti. I validatori onesti farebbero lo stesso perché anche il loro algoritmo di scelta della diramazione vederebbe la catena preferita dall'utente malevolo come la più pesante, quindi la catena potrebbe finalizzarsi. Ciò consente all'utente malevolo di censurare certe transazioni, apportare riorganizzazioni a breve raggio ed estrarre il MEV massimo riordinando i blocchi a proprio favore. La difesa contro tale attacco è l'enorme costo di uno stake di maggioranza (attualmente di poco inferiore a 19 miliardi di USD) messo a rischio da un utente malevolo, poiché il livello sociale potrebbe intervenire e adottare una diramazione di minoranza onesta svalutando drasticamente lo stake dell'utente malevolo. + +### Utenti malevoli che utilizzano il >=66% dello stake totale {#attackers-with-66-stake} + +Un utente malevolo con il 66% o più dell'ether in staking totale può finalizzare la propria catena preferita senza dover forzare alcun validatore onesto. L'utente può semplicemente votare la propria diramazione preferita per poi finalizzarla, semplicemente perché può votare con una supermaggioranza disonesta. Come detentore della supermaggioranza, controllerebbe sempre i contenuti dei blocchi finalizzati, con il potere di spendere, riavvolgere e rispendere, censurare certe transazioni e riorganizzare a piacimento la catena. Acquistando ulteriore ether per controllare il 66% invece del 51%, l'utente malevolo acquisisce di fatto l'abilità di effettuare riorganizzazioni a posteriori e inversioni di finalità (cioè, modificare il passato e controllare il futuro). Le sole vere difese sono il costo enorme del 66% dell'ether in staking totale e l'opzione di fare affidamento sul livello sociale per coordinare l'adozione di una diramazione alternativa. Possiamo affrontarlo in maggiore dettaglio nella sezione seguente. + +## Persone: l'ultima linea di difesa {#people-the-last-line-of-defense} + +Se i validatori disonesti riescono a finalizzare la propria versione preferita della catena, la community di Ethereum è messa in una situazione difficile. La catena canonica include una sezione disonesta fusa nel suo storico, mentre i validatori onesti possono ritrovarsi puniti per aver attestato una catena (onesta) alternativa. Si noti che una catena finalizzata ma errata potrebbe sorgere anche da un bug in un client di maggioranza. Infine, il ripiego finale è affidarsi al livello sociale, al Livello 0, per risolvere la situazione. + +Uno dei punti di forza del consenso di PoS di Ethereum è che esistono [svariate strategie difensive](https://youtu.be/1m12zgJ42dI?t=1712) impiegabili dalla community di fronte a un attacco. Una risposta minima potrebbe essere l'uscita forzata dei validatori malevoli dalla rete senza alcuna sanzione aggiuntiva. Per rientrare nella rete, l'utente malevolo dovrebbe unirsi a una coda di attivazione che assicura all'insieme di validatori di crescere gradualmente. Ad esempio, aggiungere abbastanza validatori da raddoppiare la quantità di ether in staking richiede circa 200 giorni, acquisendo effettivamente i validatori onesti con 200 giorni d'anticipo prima che l'utente malevolo possa tentare un altro attacco del 51%. Tuttavia, la community potrebbe anche decidere di penalizzare l'utente malevolo più duramente, revocando le ricompense passate o bruciando una certa porzione (fino al 100%) del suo capitale in staking. + +Qualsiasi sia la sanzione imposta all'utente malevolo, la community deve anche decidere se la catena disonesta, sebbene sia quella preferita dall'algoritmo di scelta della diramazione codificato nei client di Ethereum, sia di fatto non valida e se la community dovrebbe costruire, invece, sulla catena onesta. I validatori onesti potrebbero concordare collettivamente di costruire una diramazione accettata dalla community della blockchain di Ethereum che potrebbe, ad esempio, essersi separata dalla catena canonica prima dell'inizio dell'attacco o far rimuovere forzatamente i validatori malevoli. I validatori onesti sarebbero incentivati a costruire su questa catena, evitando le sanzioni loro applicate per la mancata attestazione (giustamente) della catena dell'utente malevolo. Le borse, on-ramp e applicazioni basate su Ethereum preferirebbero presumibilmente rimanere sulla catena onesta e seguirebbero i validatori onesti nella blockchain onesta. + +Tuttavia, questa sarebbe una sostanziale sfida di governance. Alcuni utenti e validatori andrebbero senza dubbio in perdita come conseguenza del ritorno alla catena onesta, le transazioni nei blocchi convalidati dopo l'attacco potrebbero essere potenzialmente ripristinate, disturbando il livello d'applicazione e, semplicemente, minando l'etica di alcuni utenti che tendono a credere che "il codice sia legge". Le borse e le applicazioni avrebbero molto probabilmente azioni esterne alla catena collegate alle transazioni sulla catena che ora potrebbero essere ripristinate, creando una cascata di ritrattazioni e revisioni che sarebbero difficili da disfare correttamente, specialmente se mischiate con guadagni disonesti, depositati nella DeFi o altri derivati con effetti secondari per gli utenti onesti. Indubbiamente alcuni utenti, forse persino istituzionali, avrebbero già beneficiato dalla catena disonesta, per scaltrezza o fortuna, e potrebbero opporsi a una diramazione per proteggere i propri guadagni. Ci sono state richieste di provare la risposta della community agli attacchi >51% così che una ragionevole mitigazione coordinata sia eseguibile rapidamente. Alcune utili osservazioni di Vitalik sono riportate su ethresear.ch [qui](https://ethresear.ch/t/timeliness-detectors-and-51-attack-recovery-in-blockchains/6925) e [qui](https://ethresear.ch/t/responding-to-51-attacks-in-casper-ffg/6363) e su Twitter, [qui](https://twitter.com/skylar_eth/status/1551798684727508992?s=20&t=oHZ1xv8QZdOgAXhxZKtHEw). L'obiettivo di una risposta sociale coordinata dovrebbe essere molto mirato e specifico sulla punizione dell'utente malevolo e sulla minimizzazione degli effetti per gli altri utenti. + +La governance è già un argomento complicato. Gestire la risposta all'emergenza del Livello 0 a una catena in finalizzazione disonesta sarebbe senza dubbio impegnativo per la community di Ethereum, ma [è successo](https://ethereum.org/en/history/#dao-fork-summary), [due volte](https://ethereum.org/en/history/#tangerine-whistle) nella storia di Ethereum). + +Tuttavia, c'è qualcosa di abbastanza soddisfacente nel ripiego finale nel mondo reale. In definitiva, anche con questo fenomenale stack tecnologico sopra di noi, se il peggio dovesse verificarsi le persone in carne ed ossa dovrebbero coordinarsi per uscirne. + +## Riepilogo {#summary} + +Questa pagina ha esplorato alcuni dei metodi in cui gli utenti malevoli potrebbero tentare di sfruttare il protocollo di consenso del proof-of-stake di Ethereum. Le riorganizzazioni e i ritardi di finalità sono stati esaminati per gli utenti malevoli con quote crescenti dell'ether in staking totale. In generale, un utente malevolo più ricco ha maggiori possibilità di successo perché il suo stake si traduce in potere di voto che può utilizzare per influenzare i contenuti dei blocchi futuri. A certi importi di soglia di ether in staking, il potere dell'utente malevolo aumenta: + +33%: ritardo di finalità + +34%: ritardo di finalità, doppia finalità + +51%: ritardo di finalità, doppia finalità, censura, controllo sul futuro della blockchain + +66%: ritardo di finalità, doppia finalità, censura, controllo sul futuro e il passato della blockchain + +Esiste anche una serie di attacchi più sofisticati che richiedono piccoli importi di ether in staking ma si affidano ad attacchi molto sofisticati con il pieno controllo sulla tempistica dei messaggi per influenzare l'insieme di validatori a proprio favore. + +In generale, nonostante questi potenziali vettori d'attacco, il rischio di un attacco di successo è basso, certamente inferiore degli equivalenti del proof-of-work. Questo perché l'elevato costo dell'ether in staking è messo a rischio da un utente malevolo che mira a sopraffare i validatori onesti con il loro potere di voto. Il livello di incentivazione integrato del "bastone e carota" protegge contro gran parte dei malfattori, specialmente con stake minori. Anche i più subdoli attacchi di rimbalzo e di bilanciamento hanno poca probabilità di successo poiché le vere condizioni di rete rendono molto difficile ottenere il pieno controllo della consegna del messaggio a sottoinsiemi specifici di validatori, e i team dei client hanno rapidamente chiuso i vettori degli attacchi di rimbalzo, bilanciamento e valanga con semplici correzioni. + +Gli attacchi del 34%, 51% o 66% richiederebbero un coordinamento fuori banda per essere risolti. Mentre ciò sarebbe probabilmente doloroso per la community, la sua capacità di rispondere fuori banda è un forte disincentivo per un utente malevolo. Il livello sociale di Ethereum è l'ultima rete di protezione: un attacco tecnicamente riuscito potrebbe ancora essere neutralizzato dalla community che si accorda per accettare una diramazione onesta. Ci sarebbe una gara tra l'utente malevolo e la community di Ethereum: i miliardi di dollari spesi su un attacco del 66% sarebbero probabilmente annientati da un attacco di coordinamento sociale con esito positivo se fosse realizzato abbastanza rapidamente, lasciando l'utente malevolo con pesanti sacchi di ether in staking illiquidi su una catena notoriamente disonesta ignorata dalla community di Ethereum. La probabilità che ciò finisca per essere redditizio per l'utente è sufficientemente bassa da essere un deterrente efficace. Per questo l'investimento nel mantenere un livello sociale coeso con valori strettamente allineati è così importante. + +## Letture consigliate {#further-reading} + +- [Versione più dettagliata di questa pagina](https://mirror.xyz/jmcook.eth/YqHargbVWVNRQqQpVpzrqEQ8IqwNUJDIpwRP7SS5FXs) +- [Vitalik sulla finalità dell'accordo](https://blog.ethereum.org/2016/05/09/on-settlement-finality/) +- [Documento LMD GHOST](https://arxiv.org/abs/2003.03052) +- [Documento Casper-FFG](https://arxiv.org/abs/1710.09437) +- [Documento Gasper](https://arxiv.org/pdf/2003.03052.pdf) +- [Specifiche del consenso di incremento del peso del propositore](https://github.com/ethereum/consensus-specs/pull/2730) +- [Attacchi di rimbalzo su ethresear.ch](https://ethresear.ch/t/prevention-of-bouncing-attack-on-ffg/6114) +- [Ricerca sul SSLE](https://ethresear.ch/t/secret-non-single-leader-election/11789) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attack-and-defense/reorg-schematic.png b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attack-and-defense/reorg-schematic.png new file mode 100644 index 00000000000..9931eb4a103 Binary files /dev/null and b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attack-and-defense/reorg-schematic.png differ diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attestations/attestation_schematic.png b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attestations/attestation_schematic.png new file mode 100644 index 00000000000..671b58e96e7 Binary files /dev/null and b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attestations/attestation_schematic.png differ diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attestations/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attestations/index.md new file mode 100644 index 00000000000..4de1e1cfb78 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/attestations/index.md @@ -0,0 +1,86 @@ +--- +title: Attestazioni +description: Descrizione delle attestazioni nella proof-of-stake di Ethereum. +lang: it +--- + +Un validatore dovrebbe creare, firmare e trasmettere una attestazione durante ogni epoca. Questa pagina delinea come appaiono queste attestazioni e come sono elaborate e comunicate tra i client di consenso. + +## Cos'è un'attestazione? {#what-is-an-attestation} + +Ogni [epoca](/glossary/#epoch) (6,4 minuti), un validatore propone un'attestazione alla rete. L'attestazione è per uno slot specifico nell'epoca. Lo scopo dell'attestazione è votare a favore della visione della catena del validatore, in particolare il blocco giustificato più recente e il primo blocco nell'epoca corrente (noti come punti di controllo `source` (origine) e `target` (destinazione)). Queste informazioni sono combinate per tutti i validatori partecipanti, consentendo alla rete di raggiungere il consenso sullo stato della blokchain. + +L'attestazione contiene i componenti seguenti: + +- `aggregation_bits`: un bitlist di validatori in cui la posizione mappa all'indice del validatore nella loro commissione; il valore (0/1) indica se il validatore ha firmato i `data` (cioè, se è attivo ed è d'accordo con il propositore del blocco) +- `data`: dettagli relativi all'attestazione, come definito sotto +- `signature`: una firma BLS che aggrega le firme dei singoli validatori + +La prima mansione per un validatore attestante è costruire `data`. I `data` contengono le seguenti informazioni: + +- `slot`: Il numero di slot a cui si riferisce l'attestazione +- `index`: Un numero che identifica a quale commissione appartiene il validatore in un dato slot +- `beacon_block_root`: Hash radice del blocco che il validatore vede alla testa della catena (il risultato dell'applicazione dell'algoritmo di scelta della diramazione) +- `source`: Parte del voto di finalità che indica ciò che i validatori vedono come il blocco giustificato più recente +- `target`: Parte del voto di finalità che indica cosa i validatori vedono come il primo blocco nell'epoca corrente + +Una volta costruiti i `data`, il validatore può capovolgere il bit in `aggregation_bits`, corrispondenti al proprio indice del validatore da 0 a 1 per mostrare di aver partecipato. + +Infine, il validatore firma l'attestazione e la trasmette sulla rete. + +### Attestazione aggregata {#aggregated-attestation} + +Le spese aggiuntive associate al trasferimento di questi dati nella rete sono molto elevate per ogni validatore. Di conseguenza, prima ancora che avvenga la trasmissione su larga scala, le attestazioni dei singoli validatori sono aggregate in reti secondarie. Questo include l'aggregazione delle firme in modo che un'attestazione che viene trasmessa includa i `dati` di consenso e un'unica firma creata combinando le firme di tutte i validatori d'accordo con tali `dati`. Ciò è verificabile utilizzando `aggregation_bits`, poiché questi forniscono l'indice di ogni validatore nella propria commissione (i cui ID sono forniti in `data`) che può essere utilizzato per richiedere le singole firme. + +In ogni epoca, un validatore in ogni rete secondaria è selezionato dall'`aggregator`. L'aggregatore raccoglie tutte le attestazioni che sente nella rete di gossip aventi `data` equivalenti propri. Il mittente di ogni attestazione corrispondente è registrato negli `aggregation_bits`. L'aggregatore trasmette quindi l'attestazione aggregata alla rete più ampia. + +Quando un validatore viene selezionato per essere un propositore di blocchi, impacchetta le attestazioni aggregate dalle reti secondarie fino all'ultimo slot nel nuovo blocco. + +### Ciclo di vita di inclusione dell'attestazione {#attestation-inclusion-lifecycle} + +1. Generazione +2. Propagazione +3. Aggregazione +4. Propagazione +5. Inclusione + +Il ciclo di vita dell'attestazione è delineato nel seguente schema: + +![ciclo di vita dell'attestazione](./attestation_schematic.png) + +## Ricompense {#rewards} + +I validatori sono ricompensati per l'invio delle attestazioni. La ricompensa dell'attestazione dipende da due variabili, la `base reward` (ricompensa di base) e l'`inclusion delay` (ritardo d'inclusione). Il miglior caso per il ritardo d'inclusione è che sia pari a 1. + +`ricompensa d'attestazione = 7/8 x ricompensa di base x (1/ritardo d'inclusione)` + +### Ricompensa di base {#base-reward} + +La ricompensa di base è calcolata secondo il numero di validatori attestanti e i loro saldi effettivi di ether in staking: + +`base reward = validator effective balance x 2^6 / SQRT(Effective balance of all active validators)` + +#### Ritardo d'inclusione {#inclusion-delay} + +Al momento del voto dei validatori sulla testa della catena (`block n`), `block n+1` non era ancora stato proposto. Pertanto, le attestazioni sono incluse naturalmente **un blocco più tardi**, così che tutte le attestazioni che hanno votato sul `block n`, che è la testa della catena, sono incluse in `block n+1` e il **ritardo d'inclusione** è 1. Se il ritardo d'inclusione raddoppia a due slot, la ricompensa di attestazione si dimezza, perché per calcolare la ricompensa di attestazione la ricompensa di base è moltiplicata per il reciproco del ritardo d'inclusione. + +### Scenari di attestazione {#attestation-scenarios} + +#### Validatore votante mancante {#missing-voting-validator} + +I validatori hanno un massimo di 1 epoca per inviare le proprie attestazioni. Se l'attestazione era mancante nell'epoca 0, può essere inviata con un ritardo d'inclusione nell'epoca 1. + +#### Aggregatore mancante {#missing-aggregator} + +Per ogni epoca ci sono in totale 16 Aggregatori. Inoltre, alcuni validatori casuali si iscrivono a **due reti secondarie per 256 epoche** e servono da backup nel caso in cui gli aggregatori siano mancanti. + +#### Propositore di blocchi mancante {#missing-block-proposer} + +Si noti che in alcuni casi un aggregatore fortunato potrebbe anche diventare il propositore di blocchi. Se l'attestazione non è stata inclusa perché il propositore di blocchi è mancante, sarebbe il propositore successivo a selezionare l'attestazione aggregata e includerla nel blocco successivo. Tuttavia, il **ritardo d'inclusione** aumenterebbe di uno. + +## Lettura consigliate {#further-reading} + +- [Le attestazioni nelle specifiche del consenso annotate da Vitalik](https://github.com/ethereum/annotated-spec/blob/master/phase0/beacon-chain.md#attestationdata) +- [Le attestazioni su eth2book.info](https://eth2book.info/altair/part3/containers/dependencies#attestationdata) + +_Conosci una risorsa pubblica che ti è stata utile? Modifica questa pagina e aggiungila!_ diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/block-proposal/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/block-proposal/index.md new file mode 100644 index 00000000000..bd2dc9ee8ca --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/block-proposal/index.md @@ -0,0 +1,69 @@ +--- +title: Proposta di blocco +description: Spiegazione di come vengono proposti i blocchi nel proof-of-stake di Ethereum. +lang: it +--- + +I blocchi costituiscono le unità fondamentali della blockchain. I blocchi sono unità discrete di informazioni che vengono passate tra i nodi, concordate e aggiunte al database di ciascun nodo. Questa pagina spiega come sono prodotti. + +## Prerequisiti {#prerequisites} + +L'azione di proporre un blocco fa parte del protocollo di proof-of-stake. Per aiutarti a capire questa pagina, ti consigliamo di informarti sul [proof-of-stake](src/content/developers/docs/consensus-mechanisms/pos/) e sull'[architettura del blocco](src/content/developers/docs/blocks/). + +## Chi produce i blocchi? {#who-produces-blocks} + +I conti del validatore propongono i blocchi. I conti del validatore sono gestiti dagli operatori dei nodi che eseguono il software del validatore come parte dei propri client di esecuzione e di consenso e hanno depositato almeno 32 ETH nel contratto di deposito. Tuttavia, ogni validatore è responsabile solo occasionalmente della proposta di un blocco. Ethereum misura il tempo in slot ed epoche. Ogni slot è di dodici secondi, e 32 slot (6,4 minuti) compongono un'epoca. Ogni slot è un'opportunità per aggiungere un nuovo blocco a Ethereum. + +### Selezione casuale {#random-selection} + +Un unico validatore è pseudo-casualmente scelto per proporre un blocco per ogni slot. Non esiste una vera casualità in una blockchain, poiché se ogni nodo generasse genuinamente dei numeri casuali non si arriverebbe mai al consenso. Invece, l'obiettivo è di rendere imprevedibile il processo di selezione del validatore. La casualità su Ethereum è ottenuta utilizzando un algoritmo chiamato RANDAO, che combina un hash dal propositore di blocchi con un seed aggiornato a ogni blocco. Questo valore è utilizzato per selezionare un validatore specifico dall'insieme totale di validatori. La selezione del validatore è fissata con due epoche in anticipo come forma di protezione da certi tipi di manipolazione del seed. + +Sebbene i validatori si aggiungano al RANDAO in ogni slot, il valore globale del RANDAO è aggiornato solo una volta per epoca. Per calcolare l'indice del propositore di blocchi successivo, il valore del RANDAO è combinato con il numero di slot per dare un valore univoco a ogni slot. La probabilità che un singolo validatore sia selezionato non è semplicemente `1/N` (dove `N` = validatori attivi totali). Invece, è ponderata per il saldo di ETH effettivo di ogni validatore. Il saldo effettivo massimo è di 32 ETH (ciò significa che `balance < 32 ETH` comporta un peso minore di `balance == 32 ETH`, ma `balance > 32 ETH` non comporta un peso maggiore di `balance == 32 ETH`). + +Solo un propositore di blocchi è selezionato per ogni slot. In condizioni normali, un singolo produttore di blocchi crea e rilascia un unico blocco nello slot dedicato. Creare due blocchi per lo stesso slot è un’infrazione tagliabile, spesso nota come "equivoco". + +## Come è creato il blocco? {#how-is-a-block-created} + +Il propositore di blocchi dovrebbe trasmettere un blocco beacon firmato che si basa sulla testa della catena più recente secondo la vista del proprio algoritmo di scelta della diramazione eseguito localmente. L'algoritmo di scelta della diramazione si applica a qualsiasi attestazione accodata rimanente dallo slot precedente, quindi trova il blocco con il peso accumulato maggiore delle attestazioni nel suo storico. Quel blocco è genitore del nuovo blocco creato dal propositore. + +Il propositore di blocchi crea un blocco raccogliendo i dati dal suo database locale e dalla sua vista della catena. I contenuti del blocco sono mostrati nel frammento seguente: + +```rust +class BeaconBlockBody(Container): + randao_reveal: BLSSignature + eth1_data: Eth1Data + graffiti: Bytes32 + proposer_slashings: List[ProposerSlashing, MAX_PROPOSER_SLASHINGS] + attester_slashings: List[AttesterSlashing, MAX_ATTESTER_SLASHINGS] + attestations: List[Attestation, MAX_ATTESTATIONS] + deposits: List[Deposit, MAX_DEPOSITS] + voluntary_exits: List[SignedVoluntaryExit, MAX_VOLUNTARY_EXITS] + sync_aggregate: SyncAggregate + execution_payload: ExecutionPayload +``` + +Il campo `randao_reveal` prende un valore casuale verificabile che il propositore di blocchi crea aggiungendo un po' della propria entropia al valore accumulato del RANDAO dai blocchi precedenti. `eth1_data` è un voto per la vista del contratto di deposito da parte del propositore di blocchi, che include la radice dell'albero di Merkle di deposito e il numero totale di depositi che consentono la verifica dei nuovi depositi. `graffiti` è un campo facoltativo utilizzabile per aggiungere un messaggio al blocco. `proposer_slashings` e `attester_slashings` sono campi contenenti la prova che certi validatori hanno commesso infrazioni tagliabili secondo la vista della catena del propositore. `deposits` è un elenco di nuovi depositi del validatore di cui il propositore di blocchi è consapevole, e `voluntary_exits` è un elenco di validatori che desiderano uscire di cui il propositore di blocchi è venuto a conoscenza sulla rete di gossip del livello di consenso. `sync_aggregate` è un vettore che mostra quali validatori erano precedentemente assegnati a una commissione di sincronizzazione (un sottoinsieme di validatori che servono i dati dei client leggeri) e hanno partecipato alla firma dei dati. + +`execution_payload` consente il passaggio delle informazioni sulle transazioni tra i client di esecuzione e di consenso. `execution_payload` è un blocco di dati di esecuzione che viene nidificato in un blocco beacon. I campi in `execution_payload` riflettono la struttura dei blocchi delineata nello Yellow Paper di Ethereum, tranne che non esistono ommer e che `prev_randao` esiste al posto della `difficulty`. Il client di esecuzione ha accesso a un pool locale di transazioni di cui è venuto a conoscenza sulla propria rete di gossip. Queste transazioni sono eseguite localmente per generare un albero di stato aggiornato, noto come post-stato. Le transazioni sono incluse nell'`execution_payload` come un elenco detto `transactions` e il post-stato è fornito nel campo `state-root`. + +Tutti questi dati sono raccolti in un blocco beacon, firmati e trasmessi ai pari del propositore di blocchi, che li distribuiscono ai loro pari, ecc. + +Maggiori informazioni più sull'[anatomia dei blocchi](/developers/docs/blocks). + +## Cosa succede al blocco? {#what-happens-to-blocks} + +Il blocco è aggiunto al database locale del propositore di blocchi e trasmesso ai pari tramite la rete di gossip del livello di consenso. Quando un validatore riceve il blocco, verifica i dati al suo interno, anche controllando che il blocco abbia il genitore corretto, corrisponda allo slot corretto, che l'indice del propositore sia quello previsto, che l'indicazione del RANDAO sia valida e che il propositore non sia tagliato. `execution_payload` è scompattato e il client di esecuzione del validatore ri-esegue le transazioni nell'elenco per verificare il cambiamento di stato proposto. Supponendo che il blocco superi tutti questi controlli, ogni validatore aggiunge il blocco alla propria catena canonica. Il processo quindi ricomincia nello slot successivo. + +## Ricompense del blocco {#block-rewards} + +Il propositore del blocco riceve il pagamento per il proprio lavoro. Esiste una `base_reward` calcolata come funzione del numero di validatori attivi e dei loro saldi effettivi. Il propositore del blocco, quindi, riceve una frazione della `base_reward` per ogni attestazione valida inclusa nel blocco; più validatori attestano al blocco, maggiore è la ricompensa del suo propositore. Esiste anche una ricompensa per aver segnalato i validatori che dovrebbero essere tagliati, pari a `1/512 * saldo effettivo` per ogni validatore tagliato. + +[Maggiori informazioni su ricompense e sanzioni](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties) + +## Letture consigliate {#further-reading} + +- [Introduzione ai blocchi](/developers/docs/blocks/) +- [Introduzione al proof-of-stake](/developers/docs/consensus-mechanisms/pos/) +- [Specifiche del consenso di Ethereum](www.github.com/ethereum/consensus-specs) +- [Introduzione a Gasper](/developers/docs/consensus-mechanisms/pos/) +- [Aggiornare Ethereum](https://eth2book.info/) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/faqs/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/faqs/index.md new file mode 100644 index 00000000000..3dd135a6532 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/faqs/index.md @@ -0,0 +1,172 @@ +--- +title: Domande frequenti +description: Domande frequenti sull'Ethereum di proof-of-stake. +lang: it +--- + +## Cos'è il proof-of-stake {#what-is-proof-of-stake} + +Il proof-of-stake è una classe di algoritmo che può fornire sicurezza alle blockchain assicurandosi che le risorse di valore siano perse dagli utenti malevoli che agiscono in modo disonesto. I sistemi di proof-of-stake richiedono che una serie di validatori rendano disponibili delle risorse che possono essere distrutte se il validatore adotta certi comportamenti comprovatamente disonesti. Ethereum utilizza il meccanismo di proof-of-stake per proteggere la blockchain. + +## Come si distingue il proof-of-stake dal proof-of-work? {#comparison-to-proof-of-work} + +Sia il proof-of-work che il proof-of-stake sono meccanismi che disincentivano economicamente gli utenti malevoli dallo spam o da truffe alla rete. In entrambi i casi, i nodi che partecipano attivamente al consenso mettono "nella rete" alcune risorse che perderanno se si comportano scorrettamente. + +Nel proof-of-work, tale risorsa è l'energia. Il nodo, noto come miner, esegue un algoritmo che mira a calcolare un valore più velocemente di ogni altro nodo. Il nodo più veloce ha il diritto di proporre un blocco alla catena. Per modificare lo storico della catena o dominare la proposta dei blocchi, un miner dovrebbe avere tanta potenza di calcolo da vincere sempre la gara. Ciò è costoso in modo proibitivo e difficile da eseguire, il che protegge la catena dagli attacchi. L'energia necessaria a "minare" utilizzando il proof-of-work è una risorsa del mondo reale pagata dai miner. + +Il proof-of-stake richiede che i nodi, noti come validatori, inviino esplicitamente una risorsa di criptovalute a un contratto intelligente. Se un validatore si comporta male, questa criptovaluta può essere distrutta perché sta "mettendo in staking" le sue risorse direttamente nella catena invece che indirettamente tramite il consumo energetico. + +Il proof-of-work consuma molta più energia perché il processo di mining consumata elettricità. Il proof-of-stake, d'altra parte, richiede soltanto una piccola quantità di energia: i validatori di Ethereum possono essere eseguiti persino su un dispositivo a bassa potenza, come un Raspberry Pi. Il meccanismo di proof-of-stake di Ethereum è concepito per essere più sicuro del proof-of-work, perché il costo dell'attacco è maggiore e le conseguenze sono più severe. + +Il confronto proof-of-work vs. proof-of-stake è un argomento controverso. [Il blog di Vitalik Buterin](https://vitalik.ca/general/2017/12/31/pos_faq.html#what-are-the-benefits-of-proof-of-stake-as-opposed-to-proof-of-work) e il dibattito tra Justin Drake e Lyn Alden hanno dato una buona sintesi delle argomentazioni. + + + +## Il proof-of-stake è efficiente dal punto di vista energetico? {#is-pos-energy-efficient} + +Sì. I nodi su una rete di proof-of-stake utilizzano una minuscola quantità di energia. Uno studio di terze parti ha concluso che l'intera rete di proof-of-stake di Ethereum consuma circa 0,0026 TWh/anno, circa 13.000 volte in meno del gaming nei soli Stati Uniti. + +[Di più sul consumo energetico di Ethereum](/energy-consumption/). + +## Il proof-of-stake è sicuro? {#is-pos-secure} + +Il proof-of-stake di Ethereum è molto sicuro. Il meccanismo è stato ricercato, sviluppato e testato rigorosamente negli otto anni in cui ha preso vita. Le garanzie di sicurezza sono differenti dalle blockchain di proof-of-work. Nel proof-of-stake, i validatori malevoli possono essere puniti attivamente ("tagliati") ed espulsi dall'insieme di validatori, costando un sostanziale importo di ETH. Nel proof-of-work, un utente malevolo può continuare a ripetere il proprio attacco fintanto che ha sufficiente potenza di hash. Inoltre, è più costoso compiere attacchi equivalenti sull'Ethereum con proof-of-stake rispetto al proof-of-work. Per influenzare la vitalità della catena, è necessario almeno il 33% dell'ether in staking totale sulla rete (tranne nei casi di attacchi molto sofisticati che hanno una probabilità di successo estremamente ridotta). Per controllare i contenuti dei blocchi futuri, è necessario almeno il 51% degli ETH in staking totali e per riscrivere lo storico serve oltre il 66% dello stake totale. Il protocollo di Ethereum distruggerebbe queste risorse negli scenari di attacco al 33% e 51% e tramite il consenso sociale nello scenario di attacchi del 66%. + +- [Maggiori informazioni sulla difesa del proof-of-stake di Ethereum dagli utenti malevoli](/developers/docs/consensus-mechanisms/pos/attack-and-defense) +- [Maggiori informazioni sulla progettazione del proof-of-stake](https://medium.com/@VitalikButerin/a-proof-of-stake-design-philosophy-506585978d51) + +## Il proof-of-stake rende Ethereum più economico? {#does-pos-make-ethereum-cheaper} + +No. Il costo di invio di una transazione (commissione sul carburante) è determinato da un mercato di commissioni dinamico che aumenta all'aumentare della domanda di rete. Il meccanismo di consenso non lo influenza direttamente. + +[Maggiori informazioni sul carburante](/developers/docs/gas). + +## Cosa sono i nodi, i client e i validatori? {#what-are-nodes-clients-and-validators} + +I nodi sono computer connessi alla rete di Ethereum. I client sono i software che eseguono, che trasformano il computer in un nodo. Esistono due tipi di client: di esecuzione e di consenso. Sono entrambi necessari per creare un nodo. Un validatore è un componente aggiuntivo facoltativo a un client di consenso, che consente al nodo di partecipare al consenso di proof-of-stake. Ciò significa creare e proporre blocchi quando selezionati e attestare i blocchi che sentono sulla rete. Per eseguire un validatore, l'operatore del nodo deve depositare 32 ETH nel contratto di deposito. + +- [Maggiori informazioni su nodi e client](/developers/docs/nodes-and-clients) +- [Maggiori informazioni sullo staking](/staking) + +## Il proof-of-stake è una idea nuova? {#is-pos-new} + +No. Un utente su BitcoinTalk [ha proposto l'idea di base del proof-of-stake](https://bitcointalk.org/index.php?topic=27787.0) come un aggiornamento a Bitcoin nel 2011. Erano undici anni prima che fosse pronto all'implementazione sulla Rete Principale di Ethereum. Alcune altre catene hanno implementato il proof-of-stake prima di Ethereum, ma non il meccanismo specifico di Ethereum (noto come Gasper). + +## Cosa rende speciale il proof-of-stake di Ethereum? {#why-is-ethereum-pos-special} + +Il meccanismo di proof-of-stake di Ethereum è unico nella sua progettazione. Non è stato il primo meccanismo di proof-of-stake mai progettato e implementato, ma è il più robusto. Il meccanismo di proof-of-stake è noto come "Casper". Casper definisce come i validatori sono selezionati per proporre i blocchi, come e quando sono effettuate le attestazioni, come sono contate le attestazioni, le ricompense e le sanzioni date ai validatori, le condizioni di taglio, i meccanismi di emergenza come la perdita per inattività e le condizioni per la "finalità". La finalità è la condizione secondo cui per essere considerato una parte permanente della catena canonica, un blocco deve essere votato da almeno il 66% degli ETH in staking totali sulla rete. I ricercatori hanno sviluppato Casper specificamente per Ethereum, ed Ethereum è la prima e unica blockchain ad averlo implementato. + +Oltre a Casper, il proof-of-stake di Ethereum utilizza un algoritmo di scelta della diramazione chiamato LMD-GHOST. Questo è necessario nel caso in cui sorga una condizione in cui due blocchi esistono per lo stesso slot. Ciò crea due diramazioni della blockchain. LMD-GHOST seleziona quella con il "peso" di attestazioni maggiore. Il peso è il numero di attestazioni ponderate dal saldo effettivo dei validatori. LMD-GHOST è un'esclusiva di Ethereum. + +La combinazione di Casper e LMD-GHOST è nota come Gasper. + +[Maggiori informazioni su Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) + +## Cos'è il taglio? {#what-is-slashing} + +Taglio è il termine dato alla distruzione di parte dello stake di un validatore e la sua espulsione dalla rete. L'importo di ETH perduto in un taglio scala con il numero di validatori tagliati; ciò significa che i validatori complici sono puniti più severamente dei singoli. + +[Maggiori informazioni sul taglio](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties#slashing) + +## Perché i validatori necessitano di 32 ETH? {#why-32-eth} + +I validatori devono mettere in staking ETH così che abbiano qualcosa da perdere se si comportano male. Il motivo per cui devono specificamente mettere 32 ETH in staking è per consentire di eseguire i nodi su hardware modesti. Se gli ETH minimi per validatore fossero inferiori, il numero di validatori e dunque il numero di messaggi da elaborare in ogni slot aumenterebbe, il che comporta che sarebbe necessario hardware più potente per eseguire un nodo. + +## Come sono selezionati i validatori? {#how-are-validators-selected} + +Un singolo validatore è scelto pseudo-casualmente per proporre un blocco in ogni slot utilizzando un algoritmo detto RANDAO, che combina un hash dal propositore del blocco con un seed aggiornato a ogni blocco. Questo valore è utilizzato per selezionare un validatore specifico dall'insieme totale di validatori. La selezione del validatore è fissata a quattro epoche in anticipo. + +[Maggiori informazioni sulla selezione dei validatori](/developers/docs/consensus-mechanisms/pos/block-proposal) + +## Cos'è la frantumazione dello stake? {#what-is-stake-grinding} + +La frantumazione dello stake è una categoria di attacco alle reti di proof-of-stake in cui l'utente malevolo prova a orientare l'algoritmo di selezione del validatore a favore dei propri validatori. Gli attacchi di frantumazione dello stake richiedono all'incirca metà degli ETH totali in staking. + +[Maggiori informazioni sulla frantumazione dello stake](https://eth2book.info/altair/part2/building_blocks/randomness/#randao-biasability) + +## Cos'è il taglio sociale? {#what-is-social-slashing} + +Il taglio sociale è l'abilità della community di coordinare una diramazione blockchain in risposta a un attacco. Consente alla community di riprendersi da un utente malevolo che finalizza una catena disonesta. Il taglio sociale è anche utilizzabile contro gli attacchi di censura. + +- [Maggiori informazioni sul taglio sociale](https://ercwl.medium.com/the-case-for-social-slashing-59277ff4d9c7) +- [Vitalik Buterin sul taglio sociale](https://vitalik.ca/general/2017/12/31/pos_faq.html#what-is-proof-of-stake) + +## Riceverò un taglio? {#will-i-get-slashed} + +Come validatore, è molto difficile essere tagliato a meno che non si adottino deliberatamente comportamenti malevoli. Il taglio è implementato soltanto in scenari davvero specifici in cui i validatori propongono più blocchi per lo stesso slot o si contraddicono con le proprie attestazioni – situazioni che è davvero improbabile sorgano accidentalmente. + +[Maggiori informazioni sulle condizioni di taglio](https://eth2book.info/altair/part2/incentives/slashing) + +## Cos'è il problema del "nulla in staking"? {#what-is-nothing-at-stake-problem} + +Il problema del "nulla in staking" è un problema concettuale con alcuni meccanismi di proof-of-stake in cui esistono solo ricompense e nessuna sanzione. Se non c'è nulla in staking, un validatore pragmatico è altrettanto felice di attestare qualsiasi, o persino più, diramazioni della blockchain, perché questo aumenta le sue ricompense. Ethereum aggira tale problema utilizzando le condizioni di finalità e il taglio per assicurare una catena canonica. + +[Maggiori informazioni sul problema di "nulla in staking"](https://vitalik.ca/general/2017/12/31/pos_faq.html#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed) + +## Cos'è un algoritmo di scelta della diramazione? {#what-is-a-fork-choice-algorithm} + +Un algoritmo di scelta della diramazione implementa regole che determinano quale catena sia quella canonica. In condizioni ottimali, una regola di scelta della diramazione non è necessaria poiché esiste un solo propositore di blocchi per slot e un blocco tra cui scegliere. Talvolta, però, più blocchi per lo stesso slot o informazioni in ritardo comportano più opzioni per come sono organizzati i blocchi vicino alla testa della catena. In questi casi, tutti i client devono implementare delle regole in maniera identica per assicurarsi che tutti selezionino la sequenza corretta di blocchi. L'algoritmo di scelta della diramazione codifica tali regole. + +L'algoritmo di scelta della diramazione di Ethereum si chiama LMD-GHOST. Seleziona la diramazione con il peso di attestazioni maggiore, ossia quello votato da più ETH in staking. + +[Maggiori informazioni su LMD-GHOST](/developers/docs/consensus-mechanisms/pos/gasper/#fork-choice) + +## Cos'è la finalità nel proof-of-stake? {#what-is-finality} + +La finalità nel proof-of-stake è la garanzia che un dato blocco sia una parte permanente della catena canonica e non sia annullabile tranne in caso di mancanza del consenso in cui un utente malevolo brucia il 33% dell'ether in staking totale. Questa è la finalità "cripto-economica", contrapposta alla "finalità probabilistica" che riguarda le blockchain di proof-of-work. Nella finalità probabilistica, non esistono stati finalizzati/non finalizzati espliciti per i blocchi; semplicemente, diventa sempre meno probabile che un blocco possa essere rimosso dalla catena più diventa vecchio, e gli utenti determinano da soli quando sono abbastanza certi che un blocco sia "sicuro". Con la finalità cripto-economica, le coppie di blocchi di punti di controllo devono essere votate dal 66% dell'ether in staking. Se tale condizione è soddisfatta, i blocchi tra tali punti di controllo sono esplicitamente "finalizzati". + +[Maggiori informazioni sulla finalità](/developers/docs/consensus-mechanisms/pos/#finality) + +## Cos'è la "soggettività debole"? {#what-is-weak-subjectivity} + +La soggettività debole è una funzionalità delle reti di proof-of-stake in cui le informazioni sociali sono utilizzate per confermare lo stato corrente della blockchain. I nuovi nodi, o quelli che si riuniscono alla rete dopo esser stati offline per molto tempo, possono ricevere uno stato recente così che il nodo possa vedere immediatamente se si trovano sulla catena corretta. Questi stati sono noti come "punti di controllo della soggettività debole" e sono ottenibili da altri operatori di nodi fuori banda, o dagli esploratori di blocchi, o da svariati endpoint pubblici. + +[Maggiori informazioni sulla soggettività debole](/developers/docs/consensus-mechanisms/pos/weak-subjectivity) + +## Il proof-of-stake è resistente alla censura? {#is-pos-censorship-resistant} + +La resistenza alla censura è attualmente difficile da dimostrare. Tuttavia, a differenza del proof-of-work, il proof-of-stake offre l'opzione di coordinare i tagli per punire i validatori autori di censura. Sono previste delle modifiche al protocollo per separare i costruttori dai propositori di blocchi e implementare elenchi di transazioni che i costruttori devono includere in ogni blocco. Questa proposta è nota come separazione tra propositori e costruttori e aiuta a impedire che i validatori censurino le transazioni. + +[Maggiori informazioni sulla separazione tra propositori e costruttori](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Original-basic-scheme) + +## Il sistema di proof-of-stake di Ethereum può subire attacchi al 51%? {#pos-51-attack} + +Sì. Il proof-of-stake è vulnerabile agli attacchi al 51%, proprio come il proof-of-work. Invece di richiedere il 51% della potenza di hash della rete, l'attacco richiede il 51% degli ETH totali in staking. Un utente malevolo che accumula il 51% dello stake totale ottiene il controllo dell'algoritmo di scelta della diramazione. Ciò gli consente di censurare certe transazioni, effettuare riorganizzazioni a breve raggio ed estrarre MEV riordinando i blocchi a proprio favore. + +[Maggiori informazioni sugli attacchi al proof-of-stake](/developers/docs/consensus-mechanisms/pos/attack-and-defense) + +## Cos'è il coordinamento sociale e perché è necessario? {#what-is-social-coordination} + +Il coordinamento sociale è l'ultima linea di difesa di Ethereum, che consentirebbe a una catena onesta di essere recuperata da un attacco che ha finalizzato dei blocchi disonesti. In questo caso, la community di Ethereum dovrebbe coordinarsi "fuori banda" e accordarsi sull'uso di una diramazione onesta di minoranza, tagliando i validatori malevoli nel processo. Ciò richiederebbe anche alle app e alle borse di riconoscere la diramazione onesta. + +[Maggiori informazioni sul coordinamento sociale](/developers/docs/consensus-mechanisms/pos/attack-and-defense#people-the-last-line-of-defense) + +## Il ricco si arricchisce con il proof-of-stake? {#do-rich-get-richer} + +Più ETH qualcuno ha da mettere in staking, più validatori può eseguire e più ricompense può ottenere. Le ricompense scalano linearmente con l'importo di ETH in staking e tutti ottengono in cambio la stessa percentuale. Il proof-of-work arricchisce il ricco più del proof-of-stake, perché i miner più ricchi che acquistano hardware su larga scala beneficiano dalle economie di scala, il che significa che la relazione tra ricchezza e ricompensa non è lineare. + +## Il proof-of-stake è più centralizzato del proof-of-work? {#is-pos-decentralized} + +No, il proof-of-work tende alla centralizzazione perché i costi di mining aumentano e tagliano fuori gli individui, poi tagliano fuori le piccole aziende e così via. L'attuale problema con il proof-of-stake è l'influenza dei derivati di staking liquidi (LSD). Si tratta di token rappresentanti gli ETH messi in staking da qualche fornitore, che chiunque può scambiare su mercati secondari senza prelevare gli ETH effettivi. Gli LSD consentono agli utenti di mettere in staking meno di 32 ETH, ma creano anche un rischio di centralizzazione in cui poche grandi organizzazioni possono finire per controllare gran parte dello stake. Per questo lo [staking in autonomia](/staking/solo) è l'opzione migliore per Ethereum. + +[Maggiori informazioni sulla centralizzazione dello stake in LSD](https://notes.ethereum.org/@djrtwo/risks-of-lsd) + +## Perché posso mettere soltanto gli ETH in staking? {#why-can-i-only-stake-eth} + +ETH è la valuta nativa di Ethereum. È essenziale avere una singola valuta in cui sono denominati tutti gli stake, sia per tenere conto dei saldi effettivi che per ponderare i voti e per la sicurezza. Gli stessi ETH sono componenti fondamentali di Ethereum, rispetto a un contratto intelligente. Integrare altre valute aumenterebbe significativamente la complessità, riducendo la sicurezza dello staking. + +## Ethereum è la sola blockchain di proof-of-stake? {#is-ethereum-the-only-pos-blockchain} + +No, esistono diverse blockchain di proof-of-stake. Nessuna è identica a Ethereum; il meccanismo di proof-of-stake di Ethereum è unico. + +## In cosa consiste La Fusione? {#what-is-the-merge} + +La Fusione è stata il momento in cui Ethereum ha spento il suo meccanismo di consenso basato sul proof-of-work ed è passato a quello di proof-of-stake. La Fusione si è verificata il 15 settembre 2022. + +[Maggiori informazioni sulla fusione](/roadmap/merge) + +## Cosa sono vitalità e sicurezza? {#what-are-liveness-and-safety} + +Vitalità e sicurezza sono le due preoccupazioni fondamentali in materia di sicurezza per una blockchain. La vitalità è la disponibilità di una catena che si finalizza. Se la catena smette di finalizzarsi o gli utenti non possono accedervi facilmente, si parla di perdita di vitalità. Anche un costo d'accesso estremamente elevato potrebbe essere considerato una perdita di vitalità. La sicurezza si riferisce alla difficoltà di attacco della catena, ossia finalizzare punti di controllo in conflitto. + +[Leggi di più nel documento di Casper](https://arxiv.org/pdf/1710.09437.pdf) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/gasper/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/gasper/index.md index 3da1fac82c2..ce62e76c099 100644 --- a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/gasper/index.md +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/gasper/index.md @@ -14,7 +14,7 @@ Per comprendere questo materiale, è necessario leggere la pagina introduttiva s ## Il ruolo di Gasper {#role-of-gasper} -Gasper si trova in cima a una blockchain proof-of-stake in cui i nodi forniscono ether come un deposito di sicurezza, che possono essere distrutti se sono inattivi o disonesti nel proporre o convalidare i blocchi. Gasper è il meccanismo che definisce come i validatori sono ricompensati e puniti, decide quali blocchi accettare e rifiutare e su quale biforcazione della blockchain costruire. +Gasper si trova in cima a una blockchain di proof-of-stake in cui i nodi forniscono ether come un deposito di sicurezza, che può esser distrutto se sono pigri o disonesti nel proporre o convalidare i blocchi. Gasper è il meccanismo che definisce come i validatori sono ricompensati e puniti, decide quali blocchi accettare e rifiutare e su quale biforcazione della blockchain costruire. ## Cos'è la finalità? {#what-is-finality} @@ -34,11 +34,11 @@ La prima condizione sorge perché per finalizzare una catena servono due terzi d ### Incentivi e slashing {#incentives-and-slashing} -I validatori sono ricompensati se propongono e convalidano onestamente dei blocchi. La ricompensa avviene sotto forma di Ether aggiunto al loro stake. Per contro, i validatori che sono assenti e non agiscono quando vengono invitati a farlo, perdono queste ricompense, e talvolta perdono una piccola porzione del loro stake esistente. Le sanzioni per essere offline sono comunque modeste e, nella maggior parte dei casi, ammontano al costo opportunità della mancata ricompensa. Tuttavia, è molto improbabile che alcune azioni dei validatori siano compiute accidentalmente e sono quindi indicative di qualche intento dannoso, come proporre più blocchi per lo stesso slot, attestare più blocchi per lo stesso slot o contraddire i voti del punto di controllo precedente. Si tratta di comportamenti sanzionati più duramente: lo slashing comporta la distruzione di una data parte dello stake del validatore e la sua esclusione dalla rete di validatori. Questo processo richiede 36 giorni. Al giorno 1, è prevista una sanzione iniziale di fino a 0,5 ETH. Successivamente, l'ether del validatore sanzionato "diminuisce" lentamente lungo il periodo d'uscita, ma al Giorno 18 riceve una "sanzione di correlazione", tanto maggiore quanti più validatori subiscono contemporaneamente lo slashing. La sanzione massima è rappresentata dall'intero stake. Queste ricompense e sanzioni sono pensate per incentivare i validatori onesti e disincentivare gli attacchi alla rete. +I validatori sono ricompensati se propongono e convalidano onestamente dei blocchi. La ricompensa avviene sotto forma di Ether aggiunto al loro stake. Per contro, i validatori che sono assenti e non agiscono quando vengono invitati a farlo, perdono queste ricompense, e talvolta perdono una piccola porzione del loro stake esistente. Le sanzioni per essere offline sono comunque modeste e, nella maggior parte dei casi, ammontano al costo opportunità della mancata ricompensa. Tuttavia, è molto improbabile che alcune azioni dei validatori siano compiute accidentalmente e sono quindi indicative di qualche intento dannoso, come proporre più blocchi per lo stesso slot, attestare più blocchi per lo stesso slot o contraddire i voti del punto di controllo precedente. Si tratta di comportamenti sanzionati più duramente: lo slashing comporta la distruzione di una data parte dello stake del validatore e la sua esclusione dalla rete di validatori. Questo processo richiede 36 giorni. Al giorno 1, è prevista una sanzione iniziale di un massimo di 1 ETH. Successivamente, l'ether del validatore sanzionato "diminuisce" lentamente lungo il periodo d'uscita, ma al Giorno 18 riceve una "sanzione di correlazione", tanto maggiore quanti più validatori subiscono contemporaneamente lo slashing. La sanzione massima è rappresentata dall'intero stake. Queste ricompense e sanzioni sono pensate per incentivare i validatori onesti e disincentivare gli attacchi alla rete. ### Perdita per inattività {#inactivity-leak} -Oltre alla sicurezza, Gasper prevede anche una "vitalità plausibile". Questa condizione prevede che finché due terzi dell'ether in staking totale vota onestamente e segue il protocollo, la catena potrà finalizzare, indipendentemente da qualsiasi altra attività (come attacchi, problemi di latenza o slashing). In altre parole, un terzo dell'ether in staking totale deve essere in qualche modo compromesso per impedire alla catena di finalizzare. In Gasper, esiste una linea di difesa aggiuntiva contro la perdita di vitalità, nota come "perdita per inattività". Questo meccanismo si attiva quando la catena non è riuscita a finalizzare per più di quattro epoche. I validatori che non stanno attestando attivamente alla catena di maggioranza subiscono una perdita graduale del loro stake finché la maggioranza non ottiene nuovamente i due terzi dello stake totale, garantendo così che la perdita di vitalità sia solo temporanea. +Oltre alla sicurezza, Gasper fornisce anche una "vitalità plausibile". Questa condizione prevede che finché due terzi dell'ether in staking totale vota onestamente e segue il protocollo, la catena potrà finalizzare, indipendentemente da qualsiasi altra attività (come attacchi, problemi di latenza o slashing). In altre parole, un terzo dell'ether in staking totale deve essere in qualche modo compromesso per impedire alla catena di finalizzare. In Gasper, esiste una linea di difesa aggiuntiva contro la perdita di vitalità, nota come "perdita per inattività". Questo meccanismo si attiva quando la catena non è riuscita a finalizzare per più di quattro epoche. I validatori che non stanno attestando attivamente alla catena di maggioranza subiscono una perdita graduale del loro stake finché la maggioranza non ottiene nuovamente i due terzi dello stake totale, garantendo così che la perdita di vitalità sia solo temporanea. ### Scelta della biforcazione {#fork-choice} @@ -49,4 +49,4 @@ LMD-GHOST sta per "latest message-driven greedy heaviest observed sub-tree". Si ## Letture consigliate {#further-reading} - [Gasper: combinazione di GHOST e Casper](https://arxiv.org/pdf/2003.03052.pdf) -- [Capser the Friendly Finality Gadget](https://arxiv.org/pdf/1710.09437.pdf) +- [Casper the Friendly Finality Gadget](https://arxiv.org/pdf/1710.09437.pdf) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/index.md index 2df745a7dc6..860319f20c5 100644 --- a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/index.md +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/index.md @@ -29,13 +29,26 @@ Per partecipare come validatore, un utente deve depositare 32 ETH nel contratto Se con il proof-of-work la tempistica dei blocchi è determinata dalla difficoltà di mining, nel proof-of-stake il tempo invece è fisso. Il tempo in Ethereum di proof-of-stake è diviso in slot (12 secondi) ed epoche (32 slot). In ogni slot viene selezionato casualmente un validatore come propositore di blocchi. Questo validatore è responsabile della creazione di un nuovo blocco e del suo invio ad altri nodi sulla rete. Inoltre, in ogni slot, è scelto casualmente un comitato di validatori, i cui voti sono usati per determinare la validità del blocco proposto. +## Come viene eseguita una transazione nel PoS di Ethereum {#transaction-execution-ethereum-pos} + +Di seguito è fornita una spiegazione end-to-end dell'esecuzione di una transazione nel proof-of-stake di Ethereum. + +1. Un utente crea e firma una [transazione](/developers/docs/transactions/) con la propria chiave privata. Questo processo è solitamente gestito da un portafoglio o da una libreria come [ether.js](https://docs.ethers.io/v5/), [web3js](https://web3js.readthedocs.io/en/v1.8.1/), [web3py](https://web3py.readthedocs.io/en/v5/), ecc., ma in sostanza l'utente sta facendo una richiesta a un nodo utilizzando l'[API JSON-RPC](/developers/docs/apis/json-rpc/) di Ethereum. L'utente definisce l'importo di carburante che è disposto a pagare come mancia a un validatore per incoraggiarlo a includere la transazione in un blocco. Le [mance](/developers/docs/gas/#priority-fee) sono pagate al validatore bruciando la [commissione di base](/developers/docs/gas/#base-fee). +2. La transazione è inviata a un [client di esecuzione](/developers/docs/nodes-and-clients/#execution-client) di Ethereum che ne verifica la validità. Ciò significa assicurarsi che il mittente abbia abbastanza ETH per realizzare la transazione e che l'abbia firmata con la chiave corretta. +3. Se la transazione è valida, il client di esecuzione la aggiunge al proprio mempool locale (elenco di transazioni in sospeso) e inoltre la trasmette agli altri nodi sulla rete di gossip del livello di esecuzione. Quando gli altri nodi ricevono la transazione, la aggiungono anche al proprio mempool locale. Gli utenti avanzati potrebbero astenersi dalla trasmissione della propria transazione, inoltrandola piuttosto a costruttori di blocchi specializzati, come [Flashbots Auction](https://docs.flashbots.net/flashbots-auction/overview). Ciò consente loro di organizzare le transazioni nei blocchi successivi per il massimo profitto ([MEV](/developers/docs/mev/#mev-extraction)). +4. Uno dei nodi della rete è il propositore di blocchi per lo slot corrente, che è stato precedentemente selezionato in modo pseudo-casuale utilizzando RANDAO. Questo nodo è responsabile per la costruzione e trasmissione del blocco successivo da aggiungere alla blockchain di Ethereum e di aggiornare lo stato globale. Il nodo si compone di tre parti: un client di esecuzione, un client di consenso e un client di validazione. Il client di esecuzione raggruppa le transazioni dal mempool locale in un "payload di esecuzione" e le esegue localmente per generare un cambiamento di stato. Questa informazione è passata al client di consenso, dove il payload di esecuzione è impacchettato come parte di un "blocco Beacon" che contiene anche informazioni su ricompense, sanzioni, tagli, attestazioni, ecc., che consentono alla rete di concordare sulla sequenza di blocchi alla testa della catena. La comunicazione tra i client di esecuzione e di consenso è descritta più nel dettaglio in [Connettere i client di consenso e di esecuzione](/developers/docs/networking-layer/#connecting-clients). +5. Gli altri nodi ricevono il nuovo blocco Beacon sulla rete di gossip del livello di consenso. Lo passano al proprio client di esecuzione, dove le transazioni sono rieseguite localmente per garantire che il cambiamento di stato proposto sia valido. Il client di validazione, poi, attesta che il blocco è valido e che è il blocco successivo logico nella sua visione della catena (ossia che si basa sulla catena con il maggior peso di attestazioni, come definito dalle [regole di scelta della diramazione](/developers/docs/consensus-mechanisms/pos/#fork-choice)). Il blocco è aggiunto al database locale in ogni nodo che lo attesta. +6. La transazione può essere considerabile "finalizzata", cioè non annullabile, se è diventata parte di una catena con un "collegamento di super-maggioranza" tra due punti di controllo. I punti di controllo si verificano all'inizio di ogni epoca e, per avere un collegamento di super-maggioranza, entrambi devono essere stati attestati dal 66% degli ETH in staking totali sulla rete. + +Ulteriori dettagli sulla finalità sono riportati di seguito. + ## Finalità {#finality} -Una transazione ha "finalità" nelle reti distribuite quando fa parte di un blocco che non può cambiare senza che un importo significativo di ETH sia bruciato. Su Ethereum di proof-of-stake, questo è gestito usando i blocchi di "punto di controllo" (checkpoint). Il primo blocco in ogni epoca è un punto di controllo. I validatori votano per le coppie di punti di controllo che considerano valide. Se una coppia di punti di controllo attrae voti che rappresentano almeno due terzi degli ETH in staking totali, i punti di controllo sono aggiornati. Il più recente dei due (target), diventa "giustificato". Il primo dei due è già giustificato perché era il "target" nell'epoca precedente. Ora è aggiornato a "finalizzato". Per annullare un blocco finalizzato, un utente malevolo dovrebbe impegnarsi a perdere almeno un terzo dell'offerta totale di ETH in staking. Il motivo esatto di ciò è spiegato in questo [post del blog dell'Ethereum Foundation](https://blog.ethereum.org/2016/05/09/on-settlement-finality/). Poiché la finalità richiede una maggioranza di due terzi, un utente malevolo potrebbe impedire alla rete di raggiungere la finalità votando con un terzo dello stake totale. Esiste un meccanismo per difendersi da questa eventualità: la [perdita per inattività](https://arxiv.org/pdf/2003.03052.pdf). Questa si attiva ogni volta che la catena non riesce a finalizzare per più di quattro epoche. La fuga d'inattività disperde gli ETH messi in staking dai validatori che votano contro la maggioranza, consentendo a quest'ultima di ottenere nuovamente la maggioranza di due terzi e di finalizzare la catena. +Una transazione ha "finalità" nelle reti distribuite quando fa parte di un blocco che non può cambiare senza che un importo significativo di ETH sia bruciato. Su Ethereum di proof-of-stake, questo è gestito usando i blocchi di "punto di controllo". Il primo blocco in ogni epoca è un punto di controllo. I validatori votano per le coppie di punti di controllo che considerano valide. Se una coppia di punti di controllo attrae voti che rappresentano almeno due terzi degli ETH in staking totali, i punti di controllo sono aggiornati. Il più recente dei due (destinazione) diventa "giustificato". Il primo dei due è già giustificato perché era la "destinazione" nell'epoca precedente. Ora è aggiornato a "finalizzato". Per annullare un blocco finalizzato, un utente malevolo dovrebbe impegnarsi a perdere almeno un terzo dell'offerta totale di ETH in staking. Il motivo esatto di ciò è spiegato in questo [post del blog dell'Ethereum Foundation](https://blog.ethereum.org/2016/05/09/on-settlement-finality/). Poiché la finalità richiede una maggioranza di due terzi, un utente malevolo potrebbe impedire alla rete di raggiungere la finalità votando con un terzo dello stake totale. Esiste un meccanismo per difendersi da questa eventualità: la [perdita per inattività](https://eth2book.info/bellatrix/part2/incentives/inactivity). Questa si attiva ogni volta che la catena non riesce a finalizzare per più di quattro epoche. La perdita per inattività disperde gli ETH messi in staking dai validatori che votano contro la maggioranza, consentendo a quest'ultima di ottenere nuovamente la maggioranza di due terzi e di finalizzare la catena. ## Sicurezza cripto-economica {#crypto-economic-security} -Gestire un validatore è un impegno. Il validatore deve mantenere hardware e connettività sufficienti per partecipare alla validazione e proposta dei blocchi. In cambio, il validatore è pagato in ETH (il suo saldo di staking aumenta). D'altra parte, la partecipazione come validatore apre anche nuove strade attraverso le quali gli utenti potrebbero attaccare la rete per profitto personale o sabotaggio. Per impedirlo, i validatori perdono le ricompense in ETH se non partecipano quando richiesto e il loro stake esistente può essere distrutto se si comportano in modo disonesto. Esistono due comportamenti principali considerabili disonesti: proporre diversi blocchi in uno slot singolo (equivoco) e inviare attestazioni contraddittorie. L'importo di ETH oggetto di slashing dipende da quanti validatori sono oggetto sanzionati in contemporanea. Questa è nota come la ["sanzione di correlazione"](https://arxiv.org/pdf/2003.03052.pdf) e può essere minore (circa l'1% dello stake se viene tagliato un singolo validatore) oppure può comportare la distruzione del 100% dello stake del validatore (taglio di massa). È imposta a metà strada tramite un periodo d'uscita forzato che inizia con una sanzione immediata (fino a 0,5 ETH) al Giorno 1, la sanzione di correlazione al Giorno 18 e, infine, l'espulsione dalla rete al Giorno 36. Ogni giorno ricevono modeste sanzioni d'attestazione perché sono presenti sulla rete ma non inviano voti. Tutto questo significa che un attacco coordinato sarebbe molto costoso per un utente malevolo. +Gestire un validatore è un impegno. Il validatore deve mantenere hardware e connettività sufficienti per partecipare alla validazione e proposta dei blocchi. In cambio, il validatore è pagato in ETH (il suo saldo di staking aumenta). D'altra parte, la partecipazione come validatore apre anche nuove strade attraverso le quali gli utenti potrebbero attaccare la rete per profitto personale o sabotaggio. Per impedirlo, i validatori perdono le ricompense in ETH se non partecipano quando richiesto e il loro stake esistente può essere distrutto se si comportano in modo disonesto. Esistono due comportamenti principali considerabili disonesti: proporre diversi blocchi in uno slot singolo (equivoco) e inviare attestazioni contraddittorie. L'importo di ETH oggetto di slashing dipende da quanti validatori sono oggetto sanzionati in contemporanea. Questa è nota come la ["sanzione di correlazione"](https://eth2book.info/bellatrix/part2/incentives/slashing#the-correlation-penalty) e può essere minore (circa l'1% dello stake se viene tagliato un singolo validatore) oppure può comportare la distruzione del 100% dello stake del validatore (taglio di massa). È imposta a metà strada tramite un periodo d'uscita forzato che inizia con una sanzione immediata (fino a 0,5 ETH) al Giorno 1, la sanzione di correlazione al Giorno 18 e, infine, l'espulsione dalla rete al Giorno 36. Ogni giorno ricevono modeste sanzioni d'attestazione perché sono presenti sulla rete ma non inviano voti. Tutto questo significa che un attacco coordinato sarebbe molto costoso per un utente malevolo. ## Scelta della biforcazione {#fork-choice} @@ -43,7 +56,7 @@ Quando la rete opera in modo ottimale ed onesto, c'è sempre e solo un nuovo blo ## Proof-of-stake e sicurezza {#pos-and-security} -La minaccia di un [attacco 51%](https://www.investopedia.com/terms/1/51-attack.asp) esiste ancora sul proof-of-stake, come già nel proof-of-work, ma è ancora più rischiosa per gli utenti malevoli. Un utente malevolo necessiterebbe del 51% degli ETH in staking. Potrebbero poi usare le proprie attestazioni per garantire che la propria biforcazione preferita fosse quella con le maggiori attestazioni accumulate. Il 'peso' delle attestazioni accumulate è quello che i client di consenso usano per determinare la catena corretta, così, l'utente malevolo potrebbe rendere canonica la propria biforcazione. Tuttavia, un punto di forza del proof-of-stake rispetto al proof-of-work è che la community gode di una flessibilità nel preparare un contrattacco. Ad esempio, i validatori onesti potrebbero decidere di continuare a costruire sulla catena di minoranza e ignorare la biforcazione dell'utente malevolo, incoraggiando app, scambi e pool a fare lo stesso. Potrebbero anche decidere di rimuovere forzatamente l'utente malevolo dalla rete e di distruggerne gli ETH in staking. Si tratta di difese economiche forti contro un attacco 51%. +La minaccia di un [attacco 51%](https://www.investopedia.com/terms/1/51-attack.asp) esiste ancora sul proof-of-stake, come già nel proof-of-work, ma è ancora più rischiosa per gli utenti malevoli. Un utente malevolo necessiterebbe del 51% degli ETH in staking. Potrebbero poi usare le proprie attestazioni per garantire che la propria diramazione preferita sia quella con le maggiori attestazioni accumulate. Il 'peso' delle attestazioni accumulate è quello che i client di consenso usano per determinare la catena corretta, così l'utente malevolo potrebbe rendere canonica la propria diramazione. Tuttavia, un punto di forza del proof-of-stake rispetto al proof-of-work è che la community gode di una flessibilità nel preparare un contrattacco. Ad esempio, i validatori onesti potrebbero decidere di continuare a costruire sulla catena di minoranza e ignorare la biforcazione dell'utente malevolo, incoraggiando app, scambi e pool a fare lo stesso. Potrebbero anche decidere di rimuovere forzatamente l'utente malevolo dalla rete e di distruggerne gli ETH in staking. Si tratta di difese economiche forti contro un attacco 51%. Gli attacchi 51% sono solo un tipo di attività malevola. Gli utenti malevoli potrebbero tentare attacchi a lungo raggio (sebbene il gadget di finalità neutralizzi questo vettore d'attacco), a corto raggio 'reorg' (sebbene il potenziamento del propositore e le scadenze dell'attestazione lo mitighino), attacchi di rimbalzo e bilanciamento (anch'essi mitigati dal potenziamento del propositore, fermo restando comunque che sono stati dimostrati solo in condizioni di rete idealizzate) o attacchi valanga (neutralizzati dalla regola degli algoritmi di scelta della biforcazione, di considerare solo l'ultimo messaggio). @@ -62,7 +75,7 @@ In generale è stato dimostrato che il proof-of-stake, come implementato su Ethe -## Letture consigliate {#further-reading} +## Lettura consigliate {#further-reading} - [FAQ Proof of Stake](https://vitalik.ca/general/2017/12/31/pos_faq.html) _Vitalik Buterin_ - [Cos'è il Proof of Stake](https://consensys.net/blog/blockchain-explained/what-is-proof-of-stake/) _ConsenSys_ diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/keys/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/keys/index.md new file mode 100644 index 00000000000..af23d775e78 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/keys/index.md @@ -0,0 +1,96 @@ +--- +title: Le chiavi nel proof-of-stake di Ethereum +description: Una spiegazione delle chiavi utilizzate nel meccanismo di consenso di proof-of-stake di Ethereum +lang: it +--- + +Ethereum protegge le risorse degli utenti utilizzando la crittografia a chiave pubblica-privata. La chiave pubblica è utilizzata come base per un indirizzo di Ethereum, ossia, è visibile al pubblico generale ed è utilizzata come un identificativo univoco. La chiave privata (o 'segreta') dovrebbe essere accessibile soltanto al proprietario di un conto. La chiave privata è utilizzata per 'firmare' le transazioni e i dati, così che la crittografia possa provare che il detentore approva determinate azioni di una chiave privata specifica. + +Le chiavi di Ethereum sono generate utilizzando la [crittografia a curva ellittica](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography). + +Tuttavia, quando Ethereum è passato dal [proof-of-work](/developers/docs/consensus-mechanisms/pow) al [proof-of-stake](/developers/docs/consensus-mechanisms/pos), è stato aggiunto un nuovo tipo di chiave. Le chiavi originali funzionano esattamente come prima, non ci sono state modifiche alle chiavi basate sulla curva ellittica che proteggono i conti. Tuttavia, gli utenti necessitavano di un nuovo tipo di chiave per partecipare al proof-of-stake mettendo gli ETH in staking ed eseguire i validatori. Questa esigenza è sorta dalle sfide di scalabilità associate al passaggio di molti messaggi tra grandi quantità di validatori, il che richiede un metodo crittografico facilmente aggregabile per ridurre la quantità di comunicazioni necessarie perché la rete raggiunga il consenso. + +Questo nuovo tipo di chiave utilizza lo [schema di firma di **Boneh-Lyn-Shacham (BLS)**](https://wikipedia.org/wiki/BLS_digital_signature). BLS consente un'aggregazione molto efficiente delle firme, ma consente anche di sottoporre a ingegneria inversa le chiavi dei singoli validatori aggregati ed è ideale per gestire le azioni tra validatori. + +## I due tipi di chiavi del validatore {#two-types-of-keys} + +Prima del passaggio al proof-of-stake, gli utenti di Ethereum avevano soltanto una chiave privata basata sulla curva ellittica per accedere ai propri fondi. Con l'introduzione del proof-of-stake, gli utenti che desideravano essere staker in autonomia necessitavano anche di una **chiave del validatore** e di una **chiave di prelievo**. + +### La chiave del validatore {#validator-key} + +La chiave di firma del validatore consiste in due elementi: + +- Chiave **privata** del validatore +- Chiave **pubblica** del validatore + +Lo scopo della chiave privata del validatore è firmare le operazioni sulla catena, quali proposte e attestazioni dei blocchi. Per questo, queste chiavi devono essere tenute in un portafoglio "caldo". + +Questa flessibilità ha il vantaggio di spostare molto rapidamente le chiavi di firma del validatore da un dispositivo a un altro, però se vengono perse o rubate un ladro potrebbe **agire malevolmente** in alcuni modi: + +- Far tagliare il validatore: + - Facendo il propositore e firmando due blocchi Beacon differenti per lo stesso slot + - Facendo l'attestatore e firmando un'attestazione che ne "circonda" un'altra + - Facendo l'attestatore e firmando due attestazioni differenti aventi la stessa destinazione +- Forzare un'uscita volontaria, che impedisce al validatore di mettere in staking e concede l'accesso al suo saldo di ETH al proprietario della chiave di prelievo + +La **chiave pubblica del validatore** è inclusa nei dati della transazione quando un utente deposita gli ETH al contratto di deposito di staking. Questi sono noti come _dati di deposito_ e consentono a Ethereum di identificare il validatore. + +### Credenziali di prelievo {#withdrawal-credentials} + +Ogni validatore ha una proprietà nota come _credenziali di prelievo_. Questo campo di 32 byte inizia con uno `0x00`, che rappresenta le credenziali di prelievo BLS, o uno `0x01`, che rappresenta le credenziali che puntano a un indirizzo di esecuzione. + +I validatori con le chiavi BLS `0x00` devono aggiornare tali credenziali affinché puntino a un indirizzo di esecuzione per poter attivare i pagamenti del saldo in eccesso o il prelievo completo dallo staking. Ciò può essere fatto fornendo un indirizzo di esecuzione nei dati di deposito durante la generazione iniziale della chiave, _O_ utilizzando la chiave di prelievo in un momento successivo per firmare e trasmettere un messaggio `BLSToExecutionChange`. + +### La chiave di prelievo {#withdrawal-key} + +La chiave di prelievo sarà necessaria per aggiornare le credenziali di prelievo affinché puntino a un indirizzo di esecuzione, se non impostato durante il deposito iniziale. Questo consentirà di iniziare a elaborare i pagamenti del saldo in eccesso, nonché di prelevare interamente i propri ETH in staking. + +Proprio come le chiavi del validatore, le chiavi di prelievo consistono in due componenti: + +- Chiave di prelievo **privata** +- Chiave di prelievo **pubblica** + +Perdere questa chiave prima di aggiornare le credenziali di prelievo al tipo `0x01` significa perdere l'accesso al saldo del validatore. Il validatore può ancora firmare le attestazioni e i blocchi poiché queste azioni richiedono la chiave privata del validatore, tuttavia vi è poco o nessun incentivo se le chiavi di prelievo vengono perse. + +Separare le chiavi del validatore dalle chiavi del conto di Ethereum consente a più validatori di essere eseguiti da un singolo utente. + +![schema della chiave del validatore](validator-key-schematic.png) + +## Derivare le chiavi da una frase di seed {#deriving-keys-from-seed} + +Se ogni 32 ETH in staking richiedessero una nuova serie di 2 chiavi completamente indipendenti, la gestione delle chiavi diverrebbe rapidamente scomoda, specialmente per gli utenti che eseguono più validatori. Invece, più chiavi del validatore sono derivabili da un'unica frase segreta comune e memorizzare tale singola frase segreta consente l'accesso a più chiavi del validatore. + +Le [frasi mnemoniche](https://en.bitcoinwiki.org/wiki/Mnemonic_phrase) e i percorsi sono funzionalità prominenti che gli utenti incontrano spesso quando [accedono](https://ethereum.stackexchange.com/questions/19055/what-is-the-difference-between-m-44-60-0-0-and-m-44-60-0) ai propri portafogli. La frase mnemonica è una sequenza di parole che agisce da seed iniziale per una chiave privata. Combinandola con dei dati aggiuntivi, la frase mnemonica genera un hash noto come la 'chiave principale'. Questa può essere vista come la radice di un albero. I rami da questo albero sono derivabili utilizzando un percorso gerarchico così che i nodi figli possano esistere come combinazioni dell'hash del loro nodo genitore e del loro indice nell'albero. Leggi informazioni sugli standard [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) e [BIP-19](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) per la generazione di chiavi basate sulla frase mnemonica. + +Questi percorsi hanno la seguente struttura, che risulterà familiare agli utenti che hanno interagito con portafogli hardware: + +``` +m/44'/60'/0'/0` +``` + +Gli slash in questo percorso separano i componenti della chiave privata come segue: + +``` +master_key / purpose / coin_type / account / change / address_index +``` + +Questa logica consente agli utenti di collegare quanti più validatori possibili a una singola **frase mnemonica**, poiché la radice dell'albero può essere comune e la differenziazione può verificarsi a livello dei rami. L'utente può **derivare qualsiasi numero di chiavi** dalla frase mnemonica. + +``` + [m / 0] + / + / +[m] - [m / 1] + \ + \ + [m / 2] +``` + +Ogni ramo è separato da uno `/`, quindi `m/2` significa iniziare con la chiave principale e seguire il ramo 2. Nello schema seguente, una singola frase mnemonica è utilizzata per memorizzare tre chiavi di prelievo, ognuna con due validatori associati. + +![logica della chiave del validatore](multiple-keys.png) + +## Lettura consigliate {#further-reading} + +- [Post del blog della Ethereum Foundation di Carl Beekhuizen](https://blog.ethereum.org/2020/05/21/keys/) +- [Generazione delle chiavi BLS12-381 dell'EIP-2333](https://eips.ethereum.org/EIPS/eip-2333) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/keys/multiple-keys.png b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/keys/multiple-keys.png new file mode 100644 index 00000000000..c0a767299da Binary files /dev/null and b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/keys/multiple-keys.png differ diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md new file mode 100644 index 00000000000..6a133f60680 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pos/rewards-and-penalties/index.md @@ -0,0 +1,90 @@ +--- +title: Ricompense e sanzioni del proof-of-stake +description: Scopri di più sugli incentivi del protocollo nel proof-of-stake di Ethereum. +lang: it +--- + +Ethereum è protetta utilizzando la sua criptovaluta nativa, ether (ETH). Gli operatori dei nodi che desiderano partecipare alla convalida dei blocchi e all'identificazione della testa della catena depositano ether in un contratto intelligente su Ethereum. Quindi sono pagati in ether per eseguire il software del validatore, che verifica la validità dei nuovi blocchi ricevuti tramite la rete peer-to-peer e applica l'algoritmo di scelta della diramazione per identificare la testa della catena. + +Esistono due ruoli principali per un validatore: 1) controllare i nuovi blocchi e "attestarne" la validità, 2) proporre nuovi blocchi quando selezionati casualmente dal gruppo totale di validatori. Se il validatore non riesce a svolgere una di queste mansioni quando richiesto, perde un pagamento di ether. Talvolta, inoltre, i validatori sono incaricati di aggregare le firme e partecipare alle commissioni di sincronizzazione. + +Esistono poi delle azioni molto difficili da compiere per errore e che denotano un intento malevolo, come proporre diversi blocchi per lo stesso slot o attestare più blocchi per lo stesso slot. Questi sono comportamenti "tagliabili" che risultano nel bruciare alcuni importi di ether (fino a 1 ETH) prima che il validatore venga rimosso dalla rete, il che richiede 36 giorni. L'ether del validatore sanzionato si riduce lentamente durante il periodo d'uscita, ma al diciottesimo giorno riceve una "sanzione di correlazione", maggiore quando più validatori sono sanzionati contemporaneamente. La struttura di incentivazione della Beacon Chain, pertanto, premia l'onestà e punisce gli attori disonesti. + +Tutte le ricompense e le sanzioni sono applicate una volta all'epoca. + +Continua a leggere per ulteriori dettagli... + +## Ricompense e sanzioni {#rewards} + +### Ricompense {#rewards} + +I validatori ricevono ricompense quando effettuano voti coerenti con la maggioranza degli altri validatori, quando propongono blocchi e quando partecipano alle commissioni di sincronizzazione. Il valore delle ricompense in ogni epoca è calcolato a partire da una `base_reward` (ricompensa di base). Questa unità fornisce le basi per il calcolo delle ricompense. La`base_reward` rappresenta la ricompensa media ricevuta da un validatore in condizioni ottimali per ogni epoca. Questa è calcolata in base al saldo effettivo del validatore e al numero totale di validatori attivi, come segue: + +``` +base_reward = effective_balance * (base_reward_factor / (base_rewards_per_epoch * sqrt(sum(active_balance)))) +``` + +dove `base_reward_factor` è 64, `base_rewards_per_epoch` è 4 e `sum(active balance)` è l'ether totale in staking tra tutti i validatori attivi. + +Ciò significa che la ricompensa di base è proporzionale al saldo effettivo del validatore ed è inversamente proporzionale al numero di validatori sulla rete. Più validatori ci sono, maggiore sarà l'emissione complessiva (poiché `sqrt(N)`), ma minore sarà la `base_reward` per validatore (come `1/sqrt(N)`). Questi fattori influenzano l'APR per un nodo di staking. Leggi la logica alla base nelle [note di Vitalik](https://notes.ethereum.org/@vbuterin/rkhCgQteN?type=view#Base-rewards). + +La ricompensa totale è quindi calcolata come la somma di cinque componenti, ognuno avente un peso che determina quanto ogni componente aggiunge alla ricompensa totale. I componenti sono: + +``` +1. voto sull'origine: il validatore ha effettuato un voto tempestivo per il punto di controllo di origine corretto +2. voto sulla destinazione: il validatore ha effettuato un voto tempestivo per il punto di controllo di destinazione corretto +3. voto sulla testa: il validatore ha effettuato un voto tempestivo per il blocco di testa corretto +4. ricompensa della commissione di sincronizzazione: il validatore ha partecipato a una commissione di sincronizzazione +5. ricompensa del propositore: il validatore ha proposto un blocco nello slot corretto +``` + +Le ponderazioni per ciascun componente sono le seguenti: + +``` +TIMELY_SOURCE_WEIGHT uint64(14) +TIMELY_TARGET_WEIGHT uint64(26) +TIMELY_HEAD_WEIGHT uint64(14) +SYNC_REWARD_WEIGHT uint64(2) +PROPOSER_WEIGHT uint64(8) +``` + +Questi pesi ammontano a 64. La ricompensa è calcolata come la somma dei pesi applicabili, divisa per 64. Un validatore che ha effettuato tempestivi voti sull'origine, sula destinazione e sulla testa, ha proposto un blocco e ha partecipato a una commissione di sincronizzazione, potrebbe ricevere `64/64 * base_reward == base_reward`. Tuttavia, solitamente un validatore non è un propositore di blocchi, quindi la sua ricompensa massima è `64-8 /64 * base_reward == 7/8 * base_reward`. I validatori che non sono propositori di blocchi né partecipano a una commissione di sincronizzazione possono ricevere `64-8-2 / 64 * base_reward == 6.75/8 * base_reward`. + +È prevista una ricompensa aggiuntiva per incentivare attestazioni rapide. Questa è la `inclusion_delay_reward`. Ha un valore pari alla `base_reward`, moltiplicata per `1/delay`, dove `delay` è il numero di slot che separano la proposta e l'attestazione del blocco. Ad esempio, se l'attestazione è inviata entro uno slot della proposta del blocco, l'attestatore riceve `base_reward * 1/1 == base_reward`. Se l'attestazione arriva nello slot successivo, l'attestatore riceve `base_reward * 1/2` e così via. + +I propositori di blocchi ricevono `8 / 64 * base_reward` per **ogni attestazione valida** inclusa nel blocco, quindi il valore effettivo della ricompensa scala con il numero di validatori attestanti. I propositori di blocchi, inoltre, possono incrementare la propria ricompensa includendo prova del comportamento scorretto di altri validatori nel loro blocco proposto. Queste ricompense sono le "carote" che incoraggiano l'onestà del validatore. Un propositore di blocchi che include il taglio sarà ricompensato con `slashed_validators_effective_balance / 512`. + +### Sanzioni {#penalties} + +Finora abbiamo considerato validatori che si comportano in modo impeccabile, ma quali sono le sanzioni per i validatori che non effettuano tempestivi voti sull'origine, sulla destinazione e sulla testa o lo fanno lentamente? + +Le sanzioni per la mancanza di voti sull'origine e sulla destinazione equivalgono alle ricompense che l'attestatore avrebbe ricevuto se li avesse inviati. Ciò significa che, invece di aggiungere la ricompensa al loro saldo, si vedono rimuovere un valore equivalente dal proprio saldo. Non è presente alcuna sanzione per il mancato voto sulla testa (ossia, i voti di testa sono solo ricompensati, mai sanzionati). Non esiste alcuna sanzione associata all'`inclusion_delay`; la ricompensa, semplicemente, non sarà aggiunta al saldo del validatore. Inoltre, non esiste alcuna sanzione per la mancata proposizione di un blocco. + +Leggi di più sulle ricompense e le sanzioni nelle [specifiche del consenso](https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md). Ricompense e sanzioni sono state adeguate nell'aggiornamento di Bellatrix; guarda Danny Ryan e Vitalik discuterne in questo [Video Peep an EIP](https://www.youtube.com/watch?v=iaAEGs1DMgQ). + +## Taglio {#slashing} + +Il taglio è un'azione più grave che risulta nella rimozione forzata di un validatore dalla rete e nella perdita associata del suo ether in staking. Esistono tre modi in cui un validatore può essere tagliato, tutti equivalenti alla proposta o attestazione disonesta dei blocchi: + +- Proponendo e firmando due blocchi diversi per lo stesso slot +- Attestando un blocco che ne "circonda" un altro (modificando di fatto lo storico) +- Eseguendo un "doppio voto", attestando due candidati per lo stesso blocco + +Se queste azioni sono rilevate, il validatore viene tagliato. Ciò significa che 1/32 del suo ether in staking (fino a un massimo di 1 ether) viene immediatamente bruciato, poi inizia un periodo di rimozione di 36 giorni. Durante tale periodo di rimozione, lo stake dei validatori si riduce gradualmente. A metà periodo (18° giorno), è applicata una sanzione aggiuntiva la cui entità scala con il totale di ether in staking di tutti i validatori tagliati nei 36 giorni precedenti all'evento di taglio. Ciò significa che più validatori sono tagliati, maggiore è l'entità del taglio. Il taglio massimo è il saldo effettivo di tutti i validatori tagliati (cioè, se molti validatori sono tagliati, potrebbero perdere il proprio intero stake). D'altra parte, un evento di taglio singolo e isolato brucia soltanto una piccola porzione dello stake del validatore. Questa sanzione intermedia che scala con il numero di validatori tagliati è detta "sanzione di correlazione". + +## Perdita per inattività {#inactivity-leak} + +Se la Beacon Chain ha passato oltre quattro epoche senza finalizzare, viene attivato un protocollo d'emergenza detto "perdita per inattività". Lo scopo ultimo della perdita per inattività è creare le condizioni necessarie perché la catena recuperi la finalità. Come spiegato sopra, la finalità richiede una maggioranza dei 2/3 dell'ether in staking totale per accordarsi sui punti di controllo di origine e di destinazione. Se validatori che rappresentano oltre 1/3 dei validatori totali vanno offline o non riescono a inviare le attestazioni corrette, non è possibile che una supermaggioranza dei 2/3 finalizzi i punti di controllo. La perdita per inattività consente allo stake appartenente ai validatori inattivi di disperdersi gradualmente finché non controllano meno di 1/3 dello stake totale, consentendo ai validatori attivi rimanenti di finalizzare la catena. Indipendentemente da quanto sia grande il gruppo di validatori inattivi, i rimanenti validatori attivi alla fine controlleranno più di 2/3 dello stake. La perdita di stake è un forte incentivo per i validatori inattivi a riattivarsi appena possibile! Uno scenario di perdita per inattività è stato riscontrato sulla rete di prova Medalla quando <66% di validatori attivi è riuscito ad arrivare al consenso sulla testa corrente della blockchain. La perdita per inattività è stata attivata e la finalità è stata infine recuperata! + +La progettazione di ricompense, sanzioni e tagli della Beacon Chain incoraggia i singoli validatori a comportarsi correttamente. Tuttavia, da tali scelte di progettazione emerge un sistema che incentiva fortemente la distribuzione equa dei validatori tra i vari client e dovrebbe disincentivare fortemente il dominio di un singolo client. + +## Ulteriori letture {#further-reading} + +- [Aggiornare Ethereum: Il livello d'incentivazione](https://eth2book.info/altair/part2/incentives) +- [Incentivi nel protocollo ibrido Casper di Ethereum](https://arxiv.org/pdf/1903.04205.pdf) +- [Specifiche annotate di Vitalik](https://github.com/ethereum/annotated-spec/blob/master/phase0/beacon-chain.md#rewards-and-penalties-1) +- [Suggerimenti di prevenzione del taglio di Eth2](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50) + +_Fonti_ + +- _[https://benjaminion.xyz/eth2-annotated-spec/phase0/beacon-chain/](https://benjaminion.xyz/eth2-annotated-spec/phase0/beacon-chain/)_ diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/index.md index 742db66869a..e8ee4355849 100644 --- a/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/index.md +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/index.md @@ -41,6 +41,8 @@ Per approfondire ulteriormente la redditività del mining, usa un apposito calco ## Come avveniva il mining delle transazioni Ethereum {#how-ethereum-transactions-were-mined} +Quanto segue fornisce una panoramica di come erano minate le transazioni, nel proof-of-work di Ethereum. Una descrizione analoga di questo processo per il proof-of-stake di Ethereum, si può trovare [qui](/developers/docs/consensus-mechanisms/pos/#transaction-execution-ethereum-pos). + 1. Un utente scrive e firma una richiesta di [transazione](/developers/docs/transactions/) con la chiave privata di un [conto](/developers/docs/accounts/). 2. L'utente trasmette la richiesta di transazione all'intera rete Ethereum attraverso un [nodo](/developers/docs/nodes-and-clients/). 3. Dopo aver recepito la richiesta della nuova transazione, ogni nodo nella rete Ethereum aggiunge la richiesta alla propria mempool locale, un elenco di tutte le richieste di transazioni delle quali è venuto a conoscenza e che non sono ancora state inviate alla blockchain in un blocco. @@ -54,7 +56,13 @@ Per approfondire ulteriormente la redditività del mining, usa un apposito calco Il mining di ogni transazione (cioè l'inclusione in un nuovo blocco e la prima propagazione) avviene una volta sola, ma la transazione viene eseguita e verificata da ogni partecipante nel processo di avanzamento dello stato canonico dell'EVM. Questa è una delle regole fondamentali della blockchain: **non ti fidare, verifica**. -## Dimostrazione visiva {#a-visual-demo} +## Blocchi ommer (zio) {#ommer-blocks} + +L'estrazione di blocchi basata sul proof-of-work era solo probabilistica, il che significa che a volte due blocchi validi venivano pubblicati simultaneamente a causa della latenza della rete. In questo caso, il protocollo doveva determinare la catena più lunga (e quindi più "valida") garantendo al tempo stesso un trattamento equo dei miner, ricompensando parzialmente il blocco valido proposto non incluso. Ciò incoraggiava l'ulteriore decentralizzazione della rete in quanto i piccoli miner, che potevano trovarsi ad affrontare una latenza più elevata, potevano comunque generare rendimenti tramite ricompense per blocchi [ommer](/glossary/#ommer). + +"Ommer" è il termine preferito, neutro dal punto di vista del genere, per lo stesso livello di un blocco padre, ma a volte viene anche indicato come "zio". **Da quando Ethereum è passato alla proof-of-stake, i blocchi ommer non vengono più estratti** poiché in ogni slot viene eletto solo un proponente. Questo cambiamento può essere osservato nel [grafico storico](https://ycharts.com/indicators/ethereum_uncle_rate) dei blocchi ommer estratti. + +## Demo visiva {#a-visual-demo} Austin ti guiderà attraverso il mining e la blockchain basata sul proof-of-work. @@ -66,14 +74,6 @@ La Rete principale di Ethereum ha sempre e solo usato un algoritmo di mining: [' [Maggiori informazioni sugli algoritmi di mining](/developers/docs/consensus-mechanisms/pow/mining-algorithms/). -## Letture consigliate {#further-reading} - -## Strumenti correlati {#related-tools} - -- [I top miner di Ethereum](https://etherscan.io/stat/miner?range=7&blocktype=blocks) -- [Calcolatore di mining Etherscan](https://etherscan.io/ether-mining-calculator) -- [Calcolatore di mining Minerstat](https://minerstat.com/coin/ETH) - ## Argomenti correlati {#related-topics} - [Gas](/developers/docs/gas/) diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md new file mode 100644 index 00000000000..04537f99e8d --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md @@ -0,0 +1,334 @@ +--- +title: Dagger-Hashimoto +description: Uno sguardo dettagliato all'algoritmo di Dagger-Hashimoto. +lang: it +--- + +Dagger-Hashimoto era l'implementazione e specifica di ricerca originale per l'algoritmo di mining di Ethereum. Dagger-Hashimoto è stato sostituito da [Ethash](#ethash). Il Mining è stata disattivato completamente con[ il Merge](/updates/merge) il 15 settembre 2022. Da allora, Ethereum è stato assicurato utilizzando un meccanismo [proof-of-of-stake](/developers/docs/consensus-mechanisms/pos). Questa pagina è di interesse storico - le informazioni qui non sono più rilevanti per post-Merge Ethereum. + +## Prerequisiti {#prerequisites} + +Per meglio comprendere questa pagina, ti consigliamo prima di informarti sul [consenso proof-of-work](/developers/docs/consensus-mechanisms/pow), sul [mining](/developers/docs/consensus-mechanisms/pow/mining) e sugli [algoritmi di mining](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms). + +## Dagger-Hashimoto {#dagger-hashimoto} + +Dagger-Hashimoto punta a soddisfare due obiettivi: + +1. **Resistenza ASIC**: la creazione di hardware specializzato per l'algoritmo dovrebbe apportare un beneficio minimo +2. **Verificabilità da un client leggero**: un blocco dovrebbe essere efficientemente verificabile da un client leggero. + +Con una modifica aggiuntiva, specifichiamo anche come raggiungere un terzo obiettivo se desiderato, ma al costo di una maggiore complessità: + +**Archiviazione della catena completa**: il mining dovrebbe richiedere l'archiviazione dello stato completo della blockchain (a causa della struttura irregolare dell'albero di stato di Ethereum, prevediamo la possibilità di alcune potature (pruning), soprattutto dopo alcuni contratti usati spesso, che vogliamo comunque mantenere al minimo). + +## Generazione del DAG {#dag-generation} + +Il codice per l'algoritmo sarà definito in Python, di seguito. Per prima cosa, diamo `encode_int` per il marshaling in stringhe di interi non firmati con una precisione specificata. È dato anche il suo opposto: + +```python +NUM_BITS = 512 + +def encode_int(x): + "Encode an integer x as a string of 64 characters using a big-endian scheme" + o = '' + for _ in range(NUM_BITS / 8): + o = chr(x % 256) + o + x //= 256 + return o + +def decode_int(s): + "Unencode an integer x from a string using a big-endian scheme" + x = 0 + for c in s: + x *= 256 + x += ord(c) + return x +``` + +Poi supponiamo che `sha3` sia una funzione che prende un intero e produce un intero e che `dbl_sha3` sia una funzione double-sha3; se vogliamo convertire questo codice di riferimento in un uso d'implementazione: + +```python +from pyethereum import utils +def sha3(x): + if isinstance(x, (int, long)): + x = encode_int(x) + return decode_int(utils.sha3(x)) + +def dbl_sha3(x): + if isinstance(x, (int, long)): + x = encode_int(x) + return decode_int(utils.sha3(utils.sha3(x))) +``` + +### Parametri {#parameters} + +I parametri usati per l'algoritmo sono: + +```python +SAFE_PRIME_512 = 2**512 - 38117 # Largest Safe Prime less than 2**512 + +params = { + "n": 4000055296 * 8 // NUM_BITS, # Size of the dataset (4 Gigabytes); MUST BE MULTIPLE OF 65536 + "n_inc": 65536, # Increment in value of n per period; MUST BE MULTIPLE OF 65536 + # with epochtime=20000 gives 882 MB growth per year + "cache_size": 2500, # Size of the light client's cache (can be chosen by light + # client; not part of the algo spec) + "diff": 2**14, # Difficulty (adjusted during block evaluation) + "epochtime": 100000, # Length of an epoch in blocks (how often the dataset is updated) + "k": 1, # Number of parents of a node + "w": w, # Used for modular exponentiation hashing + "accesses": 200, # Number of dataset accesses during hashimoto + "P": SAFE_PRIME_512 # Safe Prime for hashing and random number generation +} +``` + +`P` in questo caso è un numero primo scelto in modo che `log₂(P)` sia solo di poco inferiore a 512, che corrisponde ai 512 bit che abbiamo usato per rappresentare i nostri numeri. Nota che in realtà deve essere memorizzata solo la seconda metà del DAG, quindi il requisito de-facto di RAM parte da 1 GB e cresce di 441 MB l'anno. + +### Costruzione del grafico dagger {#dagger-graph-building} + +Il primitivo di costruzione del grafico dagger è definito come segue: + +```python +def produce_dag(params, seed, length): + P = params["P"] + picker = init = pow(sha3(seed), params["w"], P) + o = [init] + for i in range(1, length): + x = picker = (picker * init) % P + for _ in range(params["k"]): + x ^= o[x % i] + o.append(pow(x, params["w"], P)) + return o +``` + +Essenzialmente, avvia un grafico come un singolo nodo, `sha3(seed)` e da lì si inizia ad aggiungere sequenzialmente gli altri nodi, a seconda dei nodi casuali precedenti. Quando viene creato un nuovo nodo, è calcolata una potenza modulare del seed per selezionare casualmente degli indici inferiori a `i` (usando il suddetto `x % i`) e i valori dei nodi a questi indici sono usati all'interno di un calcolo per generare un nuovo valore per `x`, che viene poi passato a una piccola funzione di proof-of-work (basata su XOR) per generare, infine, il valore del grafico all'indice `i`. La logica dietro questa costruzione particolare è forzare l'accesso sequenziale del DAG; il valore successivo del DAG che sarà accessibile non è determinabile finché non sia noto il valore corrente. Infine, l'esponenziazione modulare genera ulteriormente un hashing del risultato. + +Questo algoritmo si basa su diversi risultati dalla teoria dei numeri. Vedere l'appendice più avanti per una discussione. + +## Valutazione da client leggero {#light-client-evaluation} + +Questa costruzione del grafico intende consentire a ogni nodo nel grafico di essere ricostruito calcolando solamente l'albero secondario di un piccolo numero di nodi, in modo da richiedere solo una piccola quantità di memoria ausiliaria. Nota che, con k=1, l'albero secondario è solo una catena di valori che cresce al primo elemento nel DAG. + +La funzione di calcolo del client leggero per il DAG funziona così: + +```python +def quick_calc(params, seed, p): + w, P = params["w"], params["P"] + cache = {} + + def quick_calc_cached(p): + if p in cache: + pass + elif p == 0: + cache[p] = pow(sha3(seed), w, P) + else: + x = pow(sha3(seed), (p + 1) * w, P) + for _ in range(params["k"]): + x ^= quick_calc_cached(x % p) + cache[p] = pow(x, w, P) + return cache[p] + + return quick_calc_cached(p) +``` + +essenzialmente, è semplicemente una riscrittura dell'algoritmo di cui sopra, che elimina il ciclo di calcolo dei valori per l'intero DAG e sostituisce la ricerca del nodo precedente con una chiamata ricorsiva o una ricerca della cache. Nota che per `k=1`, la cache non è necessaria, anche se in realtà un'ulteriore ottimizzazione pre-calcola le prime migliaia di valori del DAG e li mantiene come una cache statica per i calcoli; vedi l'appendice per l'implementazione di un codice a riguardo. + +## Doppio buffer di DAG {#double-buffer} + +In un client completo, è usato un [_doppio buffer_](https://wikipedia.org/wiki/Multiple_buffering) di 2 DAG prodotti dalla suddetta formula. L'idea è che i DAG siano prodotti ogni `epochtime` numero di blocchi, secondo i parametri indicati sopra. Il client non usa l'ultimo DAG prodotto, ma quello precedente. Il beneficio è che consente ai DAG di essere sostituiti nel tempo senza dover prevedere un passaggio in cui i miner devono improvvisamente ricalcolare tutti i dati. In caso contrario vi sarebbe il rischio, a intervalli regolari, di un brusco rallentamento temporaneo nell'elaborazione della catena e l'aumento drastico della centralizzazione. In quei pochi minuti prima che tutti i dati siano ricalcolati sussiste quindi il rischio di un attacco 51%. + +L'algoritmo usato per generare la serie di DAG usati per calcolare il lavoro per un blocco è il seguente: + +```python +def get_prevhash(n): + from pyethereum.blocks import GENESIS_PREVHASH + from pyethereum import chain_manager + if num <= 0: + return hash_to_int(GENESIS_PREVHASH) + else: + prevhash = chain_manager.index.get_block_by_number(n - 1) + return decode_int(prevhash) + +def get_seedset(params, block): + seedset = {} + seedset["back_number"] = block.number - (block.number % params["epochtime"]) + seedset["back_hash"] = get_prevhash(seedset["back_number"]) + seedset["front_number"] = max(seedset["back_number"] - params["epochtime"], 0) + seedset["front_hash"] = get_prevhash(seedset["front_number"]) + return seedset + +def get_dagsize(params, block): + return params["n"] + (block.number // params["epochtime"]) * params["n_inc"] + +def get_daggerset(params, block): + dagsz = get_dagsize(params, block) + seedset = get_seedset(params, block) + if seedset["front_hash"] <= 0: + # No back buffer is possible, just make front buffer + return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz), + "block_number": 0}} + else: + return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz), + "block_number": seedset["front_number"]}, + "back": {"dag": produce_dag(params, seedset["back_hash"], dagsz), + "block_number": seedset["back_number"]}} +``` + +## Hashimoto {#hashimoto} + +L'idea dietro all'Hashimoto originale è usare la blockchain come dataset, eseguendo un calcolo che selezioni N indici dalla blockchain, raccolga le transazioni a quegli indici, esegua uno XOR di questi dati e restituisca l'hash del risultato. L'algoritmo originale di Thaddeus Dryja, tradotto in Python per coerenza, è il seguente: + +```python +def orig_hashimoto(prev_hash, merkle_root, list_of_transactions, nonce): + hash_output_A = sha256(prev_hash + merkle_root + nonce) + txid_mix = 0 + for i in range(64): + shifted_A = hash_output_A >> i + transaction = shifted_A % len(list_of_transactions) + txid_mix ^= list_of_transactions[transaction] << i + return txid_max ^ (nonce << 192) +``` + +Sfortunatamente, anche se Hashimoto è considerato gravoso per la RAM, si affida a un'aritmetica a 256 bit, che richiede molti calcoli. Per risolvere questo problema, Dagger-Hashimoto usa comunque solo i 64 bit meno significativi, indicizzando il proprio dataset. + +```python +def hashimoto(dag, dagsize, params, header, nonce): + m = dagsize / 2 + mix = sha3(encode_int(nonce) + header) + for _ in range(params["accesses"]): + mix ^= dag[m + (mix % 2**64) % m] + return dbl_sha3(mix) +``` + +L'uso di SHA3 doppi consente una forma di dati zero, una pre-verifica quasi istantanea, che verifica solo che sia stato fornito un valore intermedio corretto. Questo livello esterno di proof-of-work è altamente pro-ASIC e abbastanza debole, ma è pensato per rendere ancora più complicati gli attacchi DDoS, poiché per produrre un blocco che non sarà immediatamente scartato deve essere eseguito un po’ di lavoro. Ecco la versione del client leggero: + +```python +def quick_hashimoto(seed, dagsize, params, header, nonce): + m = dagsize // 2 + mix = sha3(nonce + header) + for _ in range(params["accesses"]): + mix ^= quick_calc(params, seed, m + (mix % 2**64) % m) + return dbl_sha3(mix) +``` + +## Mining e verifica {#mining-and-verifying} + +Mettiamo ora tutto insieme nell'algoritmo di mining: + +```python +def mine(daggerset, params, block): + from random import randint + nonce = randint(0, 2**64) + while 1: + result = hashimoto(daggerset, get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + if result * params["diff"] < 2**256: + break + nonce += 1 + if nonce >= 2**64: + nonce = 0 + return nonce +``` + +Ecco l'algoritmo di verifica: + +```python +def verify(daggerset, params, block, nonce): + result = hashimoto(daggerset, get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + return result * params["diff"] < 2**256 +``` + +Verifica adatta a un client leggero: + +```python +def light_verify(params, header, nonce): + seedset = get_seedset(params, block) + result = quick_hashimoto(seedset["front_hash"], get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + return result * params["diff"] < 2**256 +``` + +Inoltre, nota che Dagger-Hashimoto impone anche altri requisiti sull'intestazione del blocco: + +- Perché la verifica a due livelli funzioni, l'intestazione di un blocco deve avere sia il nonce che il valore medio di pre-sha3 +- Da qualche parte, l'intestazione di un blocco deve memorizzare la sha3 del set di seed corrente + +## Letture consigliate {#further-reading} + +_Conosci una risorsa della community che ti è stata utile? Modifica questa pagina e aggiungila!_ + +## Appendice {#appendix} + +Come notato sopra, l'RNG usato per la generazione del DAG si affida ad alcuni risultati dalla teoria dei numeri. Per prima cosa, accertiamoci che l'RNG di Lehmer che è la base per la variabile `picker` abbia un periodo ampio. In secondo luogo, mostriamo che `pow(x,3,P)` non mapperà `x` a `1` o `P-1`, a condizione che all’inizio `x ∈ [2,P-2]`. Infine, mostriamo che `pow(x,3,P)` ha un basso tasso di collisione se trattato come funzione di hashing. + +### Generatore di numeri casuali di Lehmer {#lehmer-random-number} + +Sebbene la funzione `produce_dag` non necessiti di produrre numeri casuali imparziali, un possibile rischio è dato dal fatto che `seed**i % P` prende solo una manciata di valori. Questo potrebbe fornire un vantaggio ai miner che riconoscono lo schema, rispetto a quelli che non lo conoscono. + +Per evitarlo, si è fatto ricorso a un risultato dalla teoria dei numeri. Un [_Numero primo sicuro_](https://en.wikipedia.org/wiki/Safe_prime) si definisce come numero primo `P` tale per cui anche `(P-1)/2` è un numero primo. L'_ordine_ di un membro `x` del [gruppo moltiplicativo](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` è definito come il valore minimo di `m` tale per cui 
xᵐ mod P ≡ 1
+Date queste definizioni, abbiamo: + +> Osservazione 1. Ipotizziamo che `x` sia un membro del gruppo moltiplicativo `ℤ/Pℤ` per un numero primo sicuro `P`. Se `x mod P ≠ 1 mod P` e `x mod P ≠ P-1 mod P`, allora l'ordine di `x` è `P-1` o `(P-1)/2`. + +_Dimostrazione_. Poiché `P` è un numero primo sicuro, allora per il \[Teorema di Lagrange\]\[lagrange\], l'ordine di `x` è `1`, `2`, `(P-1)/2` o `P-1`. + +L'ordine di `x` non può essere `1`, poiché secondo il Piccolo teorema di Fermat: + +
xP-1 mod P ≡ 1
+ +Quindi, `x`, deve essere un'identità moltiplicativa di `ℤ/nℤ`, che è univoca. Poiché abbiamo presupposto che `x ≠ 1`, ciò è impossibile. + +L'ordine di `x` non può essere `2` a meno che `x = P-1`, poiché ciò violerebbe il fatto che `P` sia un numero primo. + +Dalla suddetta proposizione possiamo capire che iterando `(picker * init) % P`, avrà una lunghezza del ciclo di almeno `(P-1)/2`. Questo perché abbiamo selezionato `P` come un numero primo sicuro, approssimativamente pari a una potenza superiore di due e che `init` è nell'intervallo `[2,2**256+1]`. Data la magnitudine di `P`, non dovremmo mai aspettarci un ciclo dall'esponenziazione modulare. + +Quando assegniamo la prima cella nel DAG (la variabile etichettata come `init`), calcoliamo `pow(sha3(seed) + 2, 3, P)`. A prima vista, questo non garantisce che il risultato sia `1` né `P-1`. Tuttavia, poiché `P-1` è un numero primo sicuro, abbiamo la seguente garanzia aggiuntiva, che è un corollario dell'Osservazione 1: + +> Osservazione 2. Ipotizziamo che `x` sia un membro del gruppo moltiplicativo `ℤ/Pℤ` per un numero primo sicuro `P`, e prendiamo `w` come numero naturale. Se `x mod P ≠ 1 mod P` e `x mod P ≠ P-1 mod P`, nonché `w mod P ≠ P-1 mod P` e `w mod P ≠ 0 mod P`, allora `xʷ mod P ≠ 1 mod P` e `xʷ mod P ≠ P-1 mod P` + +### Esponenziazione modulare come funzione di hash {#modular-exponentiation} + +Per certi valori di `P` e `w`, la funzione `pow(x, w, P)` potrebbe avere molte collisioni. Ad esempio, `pow(x,9,19)` prende solo i valori `{1,18}`. + +Dato che `P` è primo, allora è possibile scegliere un'appropriata `w` per una funzione di hashing di esponenziazione modulare usando il seguente risultato: + +> Osservazione 3. Prendiamo `P` come numero primo; `w` e `P-1` sono coprimi se e solo se per ogni `a` e `b` in `ℤ/Pℤ`: +> +>
+> `aʷ mod P ≡ bʷ mod P` se e solo se `a mod P ≡ b mod P` +>
+ +Dunque, dato che `P` è primo e `w` è coprimo rispetto a `P-1`, abbiamo che `|{pow(x, w, P) : x ∈ ℤ}| = P`, e questo implica che la funzione di hashing ha la frequenza di collisione minima possibile. + +Nel caso speciale in cui `P` sia un numero primo sicuro, come da noi selezionato, allora `P-1` ha solo i fattori 1, 2, `(P-1)/2` e `P-1`. Poiché `P` > 7, sappiamo che 3 è primo rispetto a `P-1`, quindi `w=3` soddisfa la proposizione precedente. + +## Algoritmo di valutazione più efficiente basato sulla cache {#cache-based-evaluation} + +```python +def quick_calc(params, seed, p): + cache = produce_dag(params, seed, params["cache_size"]) + return quick_calc_cached(cache, params, p) + +def quick_calc_cached(cache, params, p): + P = params["P"] + if p < len(cache): + return cache[p] + else: + x = pow(cache[0], p + 1, P) + for _ in range(params["k"]): + x ^= quick_calc_cached(cache, params, x % p) + return pow(x, params["w"], P) + +def quick_hashimoto(seed, dagsize, params, header, nonce): + cache = produce_dag(params, seed, params["cache_size"]) + return quick_hashimoto_cached(cache, dagsize, params, header, nonce) + +def quick_hashimoto_cached(cache, dagsize, params, header, nonce): + m = dagsize // 2 + mask = 2**64 - 1 + mix = sha3(encode_int(nonce) + header) + for _ in range(params["accesses"]): + mix ^= quick_calc_cached(cache, params, m + (mix & mask) % m) + return dbl_sha3(mix) +``` diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md new file mode 100644 index 00000000000..c49aa95c4a7 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md @@ -0,0 +1,1014 @@ +--- +title: Ethash +description: Uno sguardo dettagliato all'algoritmo Ethash. +lang: it +--- + + + Ethash era l'algoritmo di mining di proof-of-work di Ethereum. Il proof-of-work è ora stato **disattivato interamente** e, invece, Ethereum è ora protetto utilizzando il proof-of-stake. Leggi di più su La Fusione, sul proof-of-stake e sullo staking. Questa pagina è per interesse storico! + + +[Ethash](https://github.com/ethereum/wiki/wiki/Ethash) è una versione modificata dell'algoritmo [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto). Il proof-of-work di Ethash è [a elevato consumo di memoria](https://wikipedia.org/wiki/Memory-hard_function), cosa pensata per rendere l'algoritmo resistente agli ASIC. Gli ASIC di Ethash sono infine stati sviluppati, ma il mining della GPU è stata un'opzione ancora valida fino alla disattivazione del proof-of-work. Ethash è ancora usato per minare altre valute su altre reti di proof-of-work non di Ethereum. + +## Come funziona Ethash? {#how-does-ethash-work} + +La gravosità sulla memoria è ottenuta con un algoritmo di proof-of-work che richiede la scelta di sotto-serie di una risorsa fissa, dipendente dal nonce e dall'intestazione del blocco. Questa risorsa (di pochi gigabyte di dimensioni) è detta DAG. Il DAG è modificato ogni 30.000 blocchi, una finestra di circa 125 ore detta un'epoca (circa 5,2 giorni) e richiede un po' di tempo per generarsi. Poiché il DAG dipende solo dall'altezza del blocco, può esser pre-generato, ma se non è il client, deve attendere fino alla fine di questo processo per produrre un blocco. Se i client non si pre-generano e salvano anticipatamente nella cache i DAG, la rete potrebbe subire un enorme ritardo dei blocchi a ogni transizione d'epoca. Il DAG non deve necessariamente essere generato per verificare il proof-of-work, perché è essenzialmente possibile eseguire la verifica con poca CPU e poca memoria. + +Il percorso generale intrapreso dall'algoritmo è il seguente: + +1. Esiste un **seed**, calcolabile per ogni blocco scansionando fino a quel punto le intestazioni dei blocchi. +2. Dal seed, si può calcolare una **cache pseudo-casuale di 16 MB**. I client leggeri memorizzano la cache. +3. Dalla cache, possiamo generare un **dataset di 1 GB**, caratterizzato dal fatto che ogni elemento nel dataset dipende solo da una piccola quantità di elementi dalla cache. I client completi e i miner memorizzano il dataset. Il dataset cresce linearmente col tempo. +4. Durante il mining vengono prese delle fette (slice) casuali del dataset, eseguendone l'hashing. La verifica può essere effettuata con poca memoria usando la cache per rigenerare le parti specifiche del dataset necessarie, così da dover solo memorizzare la cache. + +Il grande dataset è aggiornato una volta ogni 30.000 blocchi, in questo modo l'impegno di un miner sarà per lo più quello di leggere il dataset, non effettuare modifiche a esso. + +## Definizioni {#definitions} + +Adottiamo le seguenti definizioni: + +``` +WORD_BYTES = 4 # bytes in word +DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis +DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch +CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis +CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch +CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache +EPOCH_LENGTH = 30000 # blocks per epoch +MIX_BYTES = 128 # width of mix +HASH_BYTES = 64 # hash length in bytes +DATASET_PARENTS = 256 # number of parents of each dataset element +CACHE_ROUNDS = 3 # number of rounds in cache production +ACCESSES = 64 # number of accesses in hashimoto loop +``` + +### L'uso di "SHA3" {#sha3} + +Lo sviluppo di Ethereum è coinciso con lo sviluppo dello standard SHA3 e il processo standard ha effettuato una modifica tardiva al padding dell'algoritmo di hash finalizzato, quindi, gli hash "sha3_256" e "sha3_512" di Ethereum non sono hash dello standard sha3, ma una variante, spesso definita "Keccak-256" e "Keccak-512" in altri contesti. Vedi la discussione, es. [qui](https://eips.ethereum.org/EIPS-1803), [qui](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use) o [qui](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057). + +Si ricorda che gli hash "sha3" siano presentati nella descrizione dell'algoritmo più avanti. + +## Parametri {#parameters} + +I parametri della cache e del dataset di Ethash dipendono dal numero del blocco. Le dimensioni della cache e del dataset crescono entrambe linearmente; tuttavia, prendiamo sempre il numero primo maggiore successivo alla soglia di crescita lineare, per ridurre il rischio di regolarità accidentali che determinano un comportamento ciclico. + +```python +def get_cache_size(block_number): + sz = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number // EPOCH_LENGTH) + sz -= HASH_BYTES + while not isprime(sz / HASH_BYTES): + sz -= 2 * HASH_BYTES + return sz + +def get_full_size(block_number): + sz = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number // EPOCH_LENGTH) + sz -= MIX_BYTES + while not isprime(sz / MIX_BYTES): + sz -= 2 * MIX_BYTES + return sz +``` + +Nell'appendice sono presentate tabelle delle dimensioni del dataset e della cache. + +## Generazione della cache {#cache-generation} + +Specifichiamo ora la funzione per produrre una cache: + +```python +def mkcache(cache_size, seed): + n = cache_size // HASH_BYTES + + # Sequentially produce the initial dataset + o = [sha3_512(seed)] + for i in range(1, n): + o.append(sha3_512(o[-1])) + + # Use a low-round version of randmemohash + for _ in range(CACHE_ROUNDS): + for i in range(n): + v = o[i][0] % n + o[i] = sha3_512(map(xor, o[(i-1+n) % n], o[v])) + + return o +``` + +Il processo di produzione della cache richiede dapprima il riempimento sequenziale di 32 MB di memoria, poi l'esecuzione di due passaggi dell'algoritmo _RandMemoHash_ di Sergio Demian Lerner da [_Strict Memory Hard Hashing Functions_ (2014)](http://www.hashcash.org/papers/memohash.pdf). L'output è una serie di valori a 64 byte 524288. + +## Funzione di aggregazione dei dati {#date-aggregation-function} + +Usiamo un algoritmo ispirato dall'[hash FNV](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) in alcuni casi come un sostituto non associativo per XOR. Nota che moltiplichiamo il numero primo con l'intero input a 32 bit, a differenza della specifica FNV-1, che moltiplica invece il numero primo con un byte (ottetto). + +```python +FNV_PRIME = 0x01000193 + +def fnv(v1, v2): + return ((v1 * FNV_PRIME) ^ v2) % 2**32 +``` + +Anche lo yellow paper specifica fnv come v1\*(FNV_PRIME ^ v2), tutte le implementazioni correnti usano attualmente la suddetta definizione. + +## Calcolo dell'intero dataset {#full-dataset-calculation} + +Ogni elemento da 64 byte nell'intero dataset da 1 GB è calcolato come segue: + +```python +def calc_dataset_item(cache, i): + n = len(cache) + r = HASH_BYTES // WORD_BYTES + # initialize the mix + mix = copy.copy(cache[i % n]) + mix[0] ^= i + mix = sha3_512(mix) + # fnv it with a lot of random cache nodes based on i + for j in range(DATASET_PARENTS): + cache_index = fnv(i ^ j, mix[j % r]) + mix = map(fnv, mix, cache[cache_index % n]) + return sha3_512(mix) +``` + +Essenzialmente, combiniamo i dati da 256 nodi della cache selezionati pseudo-casualmente e ne eseguiamo l'hash per calcolare il nodo del dataset. L'intero dataset è quindi generato da: + +```python +def calc_dataset(full_size, cache): + return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)] +``` + +## Ciclo principale {#main-loop} + +Ora, specifichiamo il ciclo principale in stile "hashimoto", dove aggreghiamo i dati dal dataset completo per poter produrre il valore finale per un'intestazione e nonce in particolare. Nel codice seguente, `header` rappresenta l'_hash_ SHA3-256 della rappresentazione RLP di un'intestazione del blocco _troncata_, ovvero, di un'intestazione che esclude i campi **mixHash** e **nonce**. Un `nonce` si compone degli otto byte di un intero non firmato da 64 bit, con ordinamento big-endian. Quindi `nonce[::-1]` è la rappresentazione little-endian di otto byte di quel valore: + +```python +def hashimoto(header, nonce, full_size, dataset_lookup): + n = full_size / HASH_BYTES + w = MIX_BYTES // WORD_BYTES + mixhashes = MIX_BYTES / HASH_BYTES + # combine header+nonce into a 64 byte seed + s = sha3_512(header + nonce[::-1]) + # start the mix with replicated s + mix = [] + for _ in range(MIX_BYTES / HASH_BYTES): + mix.extend(s) + # mix in random dataset nodes + for i in range(ACCESSES): + p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes + newdata = [] + for j in range(MIX_BYTES / HASH_BYTES): + newdata.extend(dataset_lookup(p + j)) + mix = map(fnv, mix, newdata) + # compress mix + cmix = [] + for i in range(0, len(mix), 4): + cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3])) + return { + "mix digest": serialize_hash(cmix), + "result": serialize_hash(sha3_256(s+cmix)) + } + +def hashimoto_light(full_size, cache, header, nonce): + return hashimoto(header, nonce, full_size, lambda x: calc_dataset_item(cache, x)) + +def hashimoto_full(full_size, dataset, header, nonce): + return hashimoto(header, nonce, full_size, lambda x: dataset[x]) +``` + +Essenzialmente, manteniamo un mix di 128 byte e recuperiamo sequenzialmente e ripetutamente 128 byte dal dataset completo e usiamo la funzione `fnv` per combinarli col mix. Vengono usati 128 byte di accesso sequenziale così che ogni ciclo dell'algoritmo recuperi sempre una pagina intera dalla RAM, minimizzando le ricerche a vuoto nel lookaside buffer che gli ASIC dovrebbero teoricamente poter evitare. + +Se l'output di questo algoritmo è inferiore all'obiettivo desiderato, allora il nonce è valido. Nota che l'applicazione aggiuntiva di `sha3_256` alla fine assicura che esista un nonce intermedio, che può essere fornito per provare che almeno una piccola quantità di lavoro è stata eseguita; questa rapida verifica di PoW esterna è utilizzabile per scopi anti-DDoS. Serve anche a fornire la garanzia statistica che il risultato sia un numero a 256 bit imparziale. + +## Mining {#mining} + +L'algoritmo di mining è definito come segue: + +```python +def mine(full_size, dataset, header, difficulty): + # zero-pad target to compare with hash on the same digit + target = zpad(encode_int(2**256 // difficulty), 64)[::-1] + from random import randint + nonce = randint(0, 2**64) + while hashimoto_full(full_size, dataset, header, nonce) > target: + nonce = (nonce + 1) % 2**64 + return nonce +``` + +## Definire l'hash del seed {#seed-hash} + +Per poter calcolare l'hash del seed da usare per fare mining su un dato blocco, usiamo il seguente algoritmo: + +```python + def get_seedhash(block): + s = '\x00' * 32 + for i in range(block.number // EPOCH_LENGTH): + s = serialize_hash(sha3_256(s)) + return s +``` + +Nota che per la fluidità delle attività di mining e verifica, consigliamo di pre-calcolare gli hash dei seed futuri e i dataset in un thread separato. + +## Letture consigliate {#further-reading} + +_Conosci una risorsa della community che ti è stata utile? Modifica questa pagina e aggiungila!_ + +## Appendice {#appendix} + +Il seguente codice dovrebbe essere anteposto se sei interessato all'esecuzione della suddetta specifica di Python come codice. + +```python +import sha3, copy + +# Assumes little endian bit ordering (same as Intel architectures) +def decode_int(s): + return int(s[::-1].encode('hex'), 16) if s else 0 + +def encode_int(s): + a = "%x" % s + return '' if s == 0 else ('0' * (len(a) % 2) + a).decode('hex')[::-1] + +def zpad(s, length): + return s + '\x00' * max(0, length - len(s)) + +def serialize_hash(h): + return ''.join([zpad(encode_int(x), 4) for x in h]) + +def deserialize_hash(h): + return [decode_int(h[i:i+WORD_BYTES]) for i in range(0, len(h), WORD_BYTES)] + +def hash_words(h, sz, x): + if isinstance(x, list): + x = serialize_hash(x) + y = h(x) + return deserialize_hash(y) + +def serialize_cache(ds): + return ''.join([serialize_hash(h) for h in ds]) + +serialize_dataset = serialize_cache + +# sha3 hash function, outputs 64 bytes +def sha3_512(x): + return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x) + +def sha3_256(x): + return hash_words(lambda v: sha3.sha3_256(v).digest(), 32, x) + +def xor(a, b): + return a ^ b + +def isprime(x): + for i in range(2, int(x**0.5)): + if x % i == 0: + return False + return True +``` + +### Dimensioni dei dati {#data-sizes} + +Le seguenti tabelle di ricerca forniscono approssimativamente 2048 epoche tabulate di dimensioni dei dati e della cache. + +```python +def get_datasize(block_number): + return data_sizes[block_number // EPOCH_LENGTH] + +def get_cachesize(block_number): + return cache_sizes[block_number // EPOCH_LENGTH] + +data_sizes = [ +1073739904, 1082130304, 1090514816, 1098906752, 1107293056, +1115684224, 1124070016, 1132461952, 1140849536, 1149232768, +1157627776, 1166013824, 1174404736, 1182786944, 1191180416, +1199568512, 1207958912, 1216345216, 1224732032, 1233124736, +1241513344, 1249902464, 1258290304, 1266673792, 1275067264, +1283453312, 1291844992, 1300234112, 1308619904, 1317010048, +1325397376, 1333787776, 1342176128, 1350561664, 1358954368, +1367339392, 1375731584, 1384118144, 1392507008, 1400897408, +1409284736, 1417673344, 1426062464, 1434451072, 1442839168, +1451229056, 1459615616, 1468006016, 1476394112, 1484782976, +1493171584, 1501559168, 1509948032, 1518337664, 1526726528, +1535114624, 1543503488, 1551892096, 1560278656, 1568669056, +1577056384, 1585446272, 1593831296, 1602219392, 1610610304, +1619000192, 1627386752, 1635773824, 1644164224, 1652555648, +1660943488, 1669332608, 1677721216, 1686109312, 1694497664, +1702886272, 1711274624, 1719661184, 1728047744, 1736434816, +1744829056, 1753218944, 1761606272, 1769995904, 1778382464, +1786772864, 1795157888, 1803550592, 1811937664, 1820327552, +1828711552, 1837102976, 1845488768, 1853879936, 1862269312, +1870656896, 1879048064, 1887431552, 1895825024, 1904212096, +1912601216, 1920988544, 1929379456, 1937765504, 1946156672, +1954543232, 1962932096, 1971321728, 1979707264, 1988093056, +1996487552, 2004874624, 2013262208, 2021653888, 2030039936, +2038430848, 2046819968, 2055208576, 2063596672, 2071981952, +2080373632, 2088762752, 2097149056, 2105539712, 2113928576, +2122315136, 2130700672, 2139092608, 2147483264, 2155872128, +2164257664, 2172642176, 2181035392, 2189426048, 2197814912, +2206203008, 2214587264, 2222979712, 2231367808, 2239758208, +2248145024, 2256527744, 2264922752, 2273312128, 2281701248, +2290086272, 2298476672, 2306867072, 2315251072, 2323639168, +2332032128, 2340420224, 2348808064, 2357196416, 2365580416, +2373966976, 2382363008, 2390748544, 2399139968, 2407530368, +2415918976, 2424307328, 2432695424, 2441084288, 2449472384, +2457861248, 2466247808, 2474637184, 2483026816, 2491414144, +2499803776, 2508191872, 2516582272, 2524970368, 2533359232, +2541743488, 2550134144, 2558525056, 2566913408, 2575301504, +2583686528, 2592073856, 2600467328, 2608856192, 2617240448, +2625631616, 2634022016, 2642407552, 2650796416, 2659188352, +2667574912, 2675965312, 2684352896, 2692738688, 2701130624, +2709518464, 2717907328, 2726293376, 2734685056, 2743073152, +2751462016, 2759851648, 2768232832, 2776625536, 2785017728, +2793401984, 2801794432, 2810182016, 2818571648, 2826959488, +2835349376, 2843734144, 2852121472, 2860514432, 2868900992, +2877286784, 2885676928, 2894069632, 2902451584, 2910843008, +2919234688, 2927622784, 2936011648, 2944400768, 2952789376, +2961177728, 2969565568, 2977951616, 2986338944, 2994731392, +3003120256, 3011508352, 3019895936, 3028287104, 3036675968, +3045063808, 3053452928, 3061837696, 3070228352, 3078615424, +3087003776, 3095394944, 3103782272, 3112173184, 3120562048, +3128944768, 3137339264, 3145725056, 3154109312, 3162505088, +3170893184, 3179280256, 3187669376, 3196056704, 3204445568, +3212836736, 3221224064, 3229612928, 3238002304, 3246391168, +3254778496, 3263165824, 3271556224, 3279944576, 3288332416, +3296719232, 3305110912, 3313500032, 3321887104, 3330273152, +3338658944, 3347053184, 3355440512, 3363827072, 3372220288, +3380608384, 3388997504, 3397384576, 3405774208, 3414163072, +3422551936, 3430937984, 3439328384, 3447714176, 3456104576, +3464493952, 3472883584, 3481268864, 3489655168, 3498048896, +3506434432, 3514826368, 3523213952, 3531603584, 3539987072, +3548380288, 3556763264, 3565157248, 3573545344, 3581934464, +3590324096, 3598712704, 3607098752, 3615488384, 3623877248, +3632265856, 3640646528, 3649043584, 3657430144, 3665821568, +3674207872, 3682597504, 3690984832, 3699367808, 3707764352, +3716152448, 3724541056, 3732925568, 3741318016, 3749706368, +3758091136, 3766481536, 3774872704, 3783260032, 3791650432, +3800036224, 3808427648, 3816815488, 3825204608, 3833592704, +3841981568, 3850370432, 3858755968, 3867147904, 3875536256, +3883920512, 3892313728, 3900702592, 3909087872, 3917478784, +3925868416, 3934256512, 3942645376, 3951032192, 3959422336, +3967809152, 3976200064, 3984588416, 3992974976, 4001363584, +4009751168, 4018141312, 4026530432, 4034911616, 4043308928, +4051695488, 4060084352, 4068472448, 4076862848, 4085249408, +4093640576, 4102028416, 4110413696, 4118805632, 4127194496, +4135583104, 4143971968, 4152360832, 4160746112, 4169135744, +4177525888, 4185912704, 4194303616, 4202691968, 4211076736, +4219463552, 4227855488, 4236246656, 4244633728, 4253022848, +4261412224, 4269799808, 4278184832, 4286578048, 4294962304, +4303349632, 4311743104, 4320130432, 4328521088, 4336909184, +4345295488, 4353687424, 4362073472, 4370458496, 4378852736, +4387238528, 4395630208, 4404019072, 4412407424, 4420790656, +4429182848, 4437571456, 4445962112, 4454344064, 4462738048, +4471119232, 4479516544, 4487904128, 4496289664, 4504682368, +4513068416, 4521459584, 4529846144, 4538232704, 4546619776, +4555010176, 4563402112, 4571790208, 4580174464, 4588567936, +4596957056, 4605344896, 4613734016, 4622119808, 4630511488, +4638898816, 4647287936, 4655675264, 4664065664, 4672451968, +4680842624, 4689231488, 4697620352, 4706007424, 4714397056, +4722786176, 4731173248, 4739562368, 4747951744, 4756340608, +4764727936, 4773114496, 4781504384, 4789894784, 4798283648, +4806667648, 4815059584, 4823449472, 4831835776, 4840226176, +4848612224, 4857003392, 4865391488, 4873780096, 4882169728, +4890557312, 4898946944, 4907333248, 4915722368, 4924110976, +4932499328, 4940889728, 4949276032, 4957666432, 4966054784, +4974438016, 4982831488, 4991221376, 4999607168, 5007998848, +5016386432, 5024763776, 5033164672, 5041544576, 5049941888, +5058329728, 5066717056, 5075107456, 5083494272, 5091883904, +5100273536, 5108662144, 5117048192, 5125436032, 5133827456, +5142215296, 5150605184, 5158993024, 5167382144, 5175769472, +5184157568, 5192543872, 5200936064, 5209324928, 5217711232, +5226102656, 5234490496, 5242877312, 5251263872, 5259654016, +5268040832, 5276434304, 5284819328, 5293209728, 5301598592, +5309986688, 5318374784, 5326764416, 5335151488, 5343542144, +5351929472, 5360319872, 5368706944, 5377096576, 5385484928, +5393871232, 5402263424, 5410650496, 5419040384, 5427426944, +5435816576, 5444205952, 5452594816, 5460981376, 5469367936, +5477760896, 5486148736, 5494536832, 5502925952, 5511315328, +5519703424, 5528089984, 5536481152, 5544869504, 5553256064, +5561645696, 5570032768, 5578423936, 5586811264, 5595193216, +5603585408, 5611972736, 5620366208, 5628750464, 5637143936, +5645528192, 5653921408, 5662310272, 5670694784, 5679082624, +5687474048, 5695864448, 5704251008, 5712641408, 5721030272, +5729416832, 5737806208, 5746194304, 5754583936, 5762969984, +5771358592, 5779748224, 5788137856, 5796527488, 5804911232, +5813300608, 5821692544, 5830082176, 5838468992, 5846855552, +5855247488, 5863636096, 5872024448, 5880411008, 5888799872, +5897186432, 5905576832, 5913966976, 5922352768, 5930744704, +5939132288, 5947522432, 5955911296, 5964299392, 5972688256, +5981074304, 5989465472, 5997851008, 6006241408, 6014627968, +6023015552, 6031408256, 6039796096, 6048185216, 6056574848, +6064963456, 6073351808, 6081736064, 6090128768, 6098517632, +6106906496, 6115289216, 6123680896, 6132070016, 6140459648, +6148849024, 6157237376, 6165624704, 6174009728, 6182403712, +6190792064, 6199176064, 6207569792, 6215952256, 6224345216, +6232732544, 6241124224, 6249510272, 6257899136, 6266287744, +6274676864, 6283065728, 6291454336, 6299843456, 6308232064, +6316620928, 6325006208, 6333395584, 6341784704, 6350174848, +6358562176, 6366951296, 6375337856, 6383729536, 6392119168, +6400504192, 6408895616, 6417283456, 6425673344, 6434059136, +6442444672, 6450837376, 6459223424, 6467613056, 6476004224, +6484393088, 6492781952, 6501170048, 6509555072, 6517947008, +6526336384, 6534725504, 6543112832, 6551500672, 6559888768, +6568278656, 6576662912, 6585055616, 6593443456, 6601834112, +6610219648, 6618610304, 6626999168, 6635385472, 6643777408, +6652164224, 6660552832, 6668941952, 6677330048, 6685719424, +6694107776, 6702493568, 6710882176, 6719274112, 6727662976, +6736052096, 6744437632, 6752825984, 6761213824, 6769604224, +6777993856, 6786383488, 6794770816, 6803158144, 6811549312, +6819937664, 6828326528, 6836706176, 6845101696, 6853491328, +6861880448, 6870269312, 6878655104, 6887046272, 6895433344, +6903822208, 6912212864, 6920596864, 6928988288, 6937377152, +6945764992, 6954149248, 6962544256, 6970928768, 6979317376, +6987709312, 6996093824, 7004487296, 7012875392, 7021258624, +7029652352, 7038038912, 7046427776, 7054818944, 7063207808, +7071595136, 7079980928, 7088372608, 7096759424, 7105149824, +7113536896, 7121928064, 7130315392, 7138699648, 7147092352, +7155479168, 7163865728, 7172249984, 7180648064, 7189036672, +7197424768, 7205810816, 7214196608, 7222589824, 7230975104, +7239367552, 7247755904, 7256145536, 7264533376, 7272921472, +7281308032, 7289694848, 7298088832, 7306471808, 7314864512, +7323253888, 7331643008, 7340029568, 7348419712, 7356808832, +7365196672, 7373585792, 7381973888, 7390362752, 7398750592, +7407138944, 7415528576, 7423915648, 7432302208, 7440690304, +7449080192, 7457472128, 7465860992, 7474249088, 7482635648, +7491023744, 7499412608, 7507803008, 7516192384, 7524579968, +7532967296, 7541358464, 7549745792, 7558134656, 7566524032, +7574912896, 7583300992, 7591690112, 7600075136, 7608466816, +7616854912, 7625244544, 7633629824, 7642020992, 7650410368, +7658794112, 7667187328, 7675574912, 7683961984, 7692349568, +7700739712, 7709130368, 7717519232, 7725905536, 7734295424, +7742683264, 7751069056, 7759457408, 7767849088, 7776238208, +7784626816, 7793014912, 7801405312, 7809792128, 7818179968, +7826571136, 7834957184, 7843347328, 7851732352, 7860124544, +7868512384, 7876902016, 7885287808, 7893679744, 7902067072, +7910455936, 7918844288, 7927230848, 7935622784, 7944009344, +7952400256, 7960786048, 7969176704, 7977565312, 7985953408, +7994339968, 8002730368, 8011119488, 8019508096, 8027896192, +8036285056, 8044674688, 8053062272, 8061448832, 8069838464, +8078227328, 8086616704, 8095006592, 8103393664, 8111783552, +8120171392, 8128560256, 8136949376, 8145336704, 8153726848, +8162114944, 8170503296, 8178891904, 8187280768, 8195669632, +8204058496, 8212444544, 8220834176, 8229222272, 8237612672, +8246000768, 8254389376, 8262775168, 8271167104, 8279553664, +8287944064, 8296333184, 8304715136, 8313108352, 8321497984, +8329885568, 8338274432, 8346663296, 8355052928, 8363441536, +8371828352, 8380217984, 8388606592, 8396996224, 8405384576, +8413772672, 8422161536, 8430549376, 8438939008, 8447326592, +8455715456, 8464104832, 8472492928, 8480882048, 8489270656, +8497659776, 8506045312, 8514434944, 8522823808, 8531208832, +8539602304, 8547990656, 8556378752, 8564768384, 8573154176, +8581542784, 8589933952, 8598322816, 8606705024, 8615099264, +8623487872, 8631876992, 8640264064, 8648653952, 8657040256, +8665430656, 8673820544, 8682209152, 8690592128, 8698977152, +8707374464, 8715763328, 8724151424, 8732540032, 8740928384, +8749315712, 8757704576, 8766089344, 8774480768, 8782871936, +8791260032, 8799645824, 8808034432, 8816426368, 8824812928, +8833199488, 8841591424, 8849976448, 8858366336, 8866757248, +8875147136, 8883532928, 8891923328, 8900306816, 8908700288, +8917088384, 8925478784, 8933867392, 8942250368, 8950644608, +8959032704, 8967420544, 8975809664, 8984197504, 8992584064, +9000976256, 9009362048, 9017752448, 9026141312, 9034530688, +9042917504, 9051307904, 9059694208, 9068084864, 9076471424, +9084861824, 9093250688, 9101638528, 9110027648, 9118416512, +9126803584, 9135188096, 9143581312, 9151969664, 9160356224, +9168747136, 9177134464, 9185525632, 9193910144, 9202302848, +9210690688, 9219079552, 9227465344, 9235854464, 9244244864, +9252633472, 9261021824, 9269411456, 9277799296, 9286188928, +9294574208, 9302965888, 9311351936, 9319740032, 9328131968, +9336516736, 9344907392, 9353296768, 9361685888, 9370074752, +9378463616, 9386849408, 9395239808, 9403629184, 9412016512, +9420405376, 9428795008, 9437181568, 9445570688, 9453960832, +9462346624, 9470738048, 9479121536, 9487515008, 9495903616, +9504289664, 9512678528, 9521067904, 9529456256, 9537843584, +9546233728, 9554621312, 9563011456, 9571398784, 9579788672, +9588178304, 9596567168, 9604954496, 9613343104, 9621732992, +9630121856, 9638508416, 9646898816, 9655283584, 9663675776, +9672061312, 9680449664, 9688840064, 9697230464, 9705617536, +9714003584, 9722393984, 9730772608, 9739172224, 9747561088, +9755945344, 9764338816, 9772726144, 9781116544, 9789503872, +9797892992, 9806282624, 9814670464, 9823056512, 9831439232, +9839833984, 9848224384, 9856613504, 9865000576, 9873391232, +9881772416, 9890162816, 9898556288, 9906940544, 9915333248, +9923721088, 9932108672, 9940496512, 9948888448, 9957276544, +9965666176, 9974048384, 9982441088, 9990830464, 9999219584, +10007602816, 10015996544, 10024385152, 10032774016, 10041163648, +10049548928, 10057940096, 10066329472, 10074717824, 10083105152, +10091495296, 10099878784, 10108272256, 10116660608, 10125049216, +10133437312, 10141825664, 10150213504, 10158601088, 10166991232, +10175378816, 10183766144, 10192157312, 10200545408, 10208935552, +10217322112, 10225712768, 10234099328, 10242489472, 10250876032, +10259264896, 10267656064, 10276042624, 10284429184, 10292820352, +10301209472, 10309598848, 10317987712, 10326375296, 10334763392, +10343153536, 10351541632, 10359930752, 10368318592, 10376707456, +10385096576, 10393484672, 10401867136, 10410262144, 10418647424, +10427039104, 10435425664, 10443810176, 10452203648, 10460589952, +10468982144, 10477369472, 10485759104, 10494147712, 10502533504, +10510923392, 10519313536, 10527702656, 10536091264, 10544478592, +10552867712, 10561255808, 10569642368, 10578032768, 10586423168, +10594805632, 10603200128, 10611588992, 10619976064, 10628361344, +10636754048, 10645143424, 10653531776, 10661920384, 10670307968, +10678696832, 10687086464, 10695475072, 10703863168, 10712246144, +10720639616, 10729026688, 10737414784, 10745806208, 10754190976, +10762581376, 10770971264, 10779356288, 10787747456, 10796135552, +10804525184, 10812915584, 10821301888, 10829692288, 10838078336, +10846469248, 10854858368, 10863247232, 10871631488, 10880023424, +10888412032, 10896799616, 10905188992, 10913574016, 10921964672, +10930352768, 10938742912, 10947132544, 10955518592, 10963909504, +10972298368, 10980687488, 10989074816, 10997462912, 11005851776, +11014241152, 11022627712, 11031017344, 11039403904, 11047793024, +11056184704, 11064570752, 11072960896, 11081343872, 11089737856, +11098128256, 11106514816, 11114904448, 11123293568, 11131680128, +11140065152, 11148458368, 11156845696, 11165236864, 11173624192, +11182013824, 11190402688, 11198790784, 11207179136, 11215568768, +11223957376, 11232345728, 11240734592, 11249122688, 11257511296, +11265899648, 11274285952, 11282675584, 11291065472, 11299452544, +11307842432, 11316231296, 11324616832, 11333009024, 11341395584, +11349782656, 11358172288, 11366560384, 11374950016, 11383339648, +11391721856, 11400117376, 11408504192, 11416893568, 11425283456, +11433671552, 11442061184, 11450444672, 11458837888, 11467226752, +11475611776, 11484003968, 11492392064, 11500780672, 11509169024, +11517550976, 11525944448, 11534335616, 11542724224, 11551111808, +11559500672, 11567890304, 11576277376, 11584667008, 11593056128, +11601443456, 11609830016, 11618221952, 11626607488, 11634995072, +11643387776, 11651775104, 11660161664, 11668552576, 11676940928, +11685330304, 11693718656, 11702106496, 11710496128, 11718882688, +11727273088, 11735660416, 11744050048, 11752437376, 11760824704, +11769216128, 11777604736, 11785991296, 11794381952, 11802770048, +11811157888, 11819548544, 11827932544, 11836324736, 11844713344, +11853100928, 11861486464, 11869879936, 11878268032, 11886656896, +11895044992, 11903433088, 11911822976, 11920210816, 11928600448, +11936987264, 11945375872, 11953761152, 11962151296, 11970543488, +11978928512, 11987320448, 11995708288, 12004095104, 12012486272, +12020875136, 12029255552, 12037652096, 12046039168, 12054429568, +12062813824, 12071206528, 12079594624, 12087983744, 12096371072, +12104759936, 12113147264, 12121534592, 12129924992, 12138314624, +12146703232, 12155091584, 12163481216, 12171864704, 12180255872, +12188643968, 12197034112, 12205424512, 12213811328, 12222199424, +12230590336, 12238977664, 12247365248, 12255755392, 12264143488, +12272531584, 12280920448, 12289309568, 12297694592, 12306086528, +12314475392, 12322865024, 12331253632, 12339640448, 12348029312, +12356418944, 12364805248, 12373196672, 12381580928, 12389969024, +12398357632, 12406750592, 12415138432, 12423527552, 12431916416, +12440304512, 12448692352, 12457081216, 12465467776, 12473859968, +12482245504, 12490636672, 12499025536, 12507411584, 12515801728, +12524190592, 12532577152, 12540966272, 12549354368, 12557743232, +12566129536, 12574523264, 12582911872, 12591299456, 12599688064, +12608074624, 12616463488, 12624845696, 12633239936, 12641631616, +12650019968, 12658407296, 12666795136, 12675183232, 12683574656, +12691960192, 12700350592, 12708740224, 12717128576, 12725515904, +12733906816, 12742295168, 12750680192, 12759071872, 12767460736, +12775848832, 12784236928, 12792626816, 12801014656, 12809404288, +12817789312, 12826181504, 12834568832, 12842954624, 12851345792, +12859732352, 12868122496, 12876512128, 12884901248, 12893289088, +12901672832, 12910067584, 12918455168, 12926842496, 12935232896, +12943620736, 12952009856, 12960396928, 12968786816, 12977176192, +12985563776, 12993951104, 13002341504, 13010730368, 13019115392, +13027506304, 13035895168, 13044272512, 13052673152, 13061062528, +13069446272, 13077838976, 13086227072, 13094613632, 13103000192, +13111393664, 13119782528, 13128157568, 13136559232, 13144945024, +13153329536, 13161724288, 13170111872, 13178502784, 13186884736, +13195279744, 13203667072, 13212057472, 13220445824, 13228832128, +13237221248, 13245610624, 13254000512, 13262388352, 13270777472, +13279166336, 13287553408, 13295943296, 13304331904, 13312719488, +13321108096, 13329494656, 13337885824, 13346274944, 13354663808, +13363051136, 13371439232, 13379825024, 13388210816, 13396605056, +13404995456, 13413380224, 13421771392, 13430159744, 13438546048, +13446937216, 13455326848, 13463708288, 13472103808, 13480492672, +13488875648, 13497269888, 13505657728, 13514045312, 13522435712, +13530824576, 13539210112, 13547599232, 13555989376, 13564379008, +13572766336, 13581154432, 13589544832, 13597932928, 13606320512, +13614710656, 13623097472, 13631477632, 13639874944, 13648264064, +13656652928, 13665041792, 13673430656, 13681818496, 13690207616, +13698595712, 13706982272, 13715373184, 13723762048, 13732150144, +13740536704, 13748926592, 13757316224, 13765700992, 13774090112, +13782477952, 13790869376, 13799259008, 13807647872, 13816036736, +13824425344, 13832814208, 13841202304, 13849591424, 13857978752, +13866368896, 13874754688, 13883145344, 13891533184, 13899919232, +13908311168, 13916692096, 13925085056, 13933473152, 13941866368, +13950253696, 13958643584, 13967032192, 13975417216, 13983807616, +13992197504, 14000582272, 14008973696, 14017363072, 14025752192, +14034137984, 14042528384, 14050918016, 14059301504, 14067691648, +14076083584, 14084470144, 14092852352, 14101249664, 14109635968, +14118024832, 14126407552, 14134804352, 14143188608, 14151577984, +14159968384, 14168357248, 14176741504, 14185127296, 14193521024, +14201911424, 14210301824, 14218685056, 14227067264, 14235467392, +14243855488, 14252243072, 14260630144, 14269021568, 14277409408, +14285799296, 14294187904, 14302571392, 14310961792, 14319353728, +14327738752, 14336130944, 14344518784, 14352906368, 14361296512, +14369685376, 14378071424, 14386462592, 14394848128, 14403230848, +14411627392, 14420013952, 14428402304, 14436793472, 14445181568, +14453569664, 14461959808, 14470347904, 14478737024, 14487122816, +14495511424, 14503901824, 14512291712, 14520677504, 14529064832, +14537456768, 14545845632, 14554234496, 14562618496, 14571011456, +14579398784, 14587789184, 14596172672, 14604564608, 14612953984, +14621341312, 14629724288, 14638120832, 14646503296, 14654897536, +14663284864, 14671675264, 14680061056, 14688447616, 14696835968, +14705228416, 14713616768, 14722003328, 14730392192, 14738784128, +14747172736, 14755561088, 14763947648, 14772336512, 14780725376, +14789110144, 14797499776, 14805892736, 14814276992, 14822670208, +14831056256, 14839444352, 14847836032, 14856222848, 14864612992, +14872997504, 14881388672, 14889775744, 14898165376, 14906553472, +14914944896, 14923329664, 14931721856, 14940109696, 14948497024, +14956887424, 14965276544, 14973663616, 14982053248, 14990439808, +14998830976, 15007216768, 15015605888, 15023995264, 15032385152, +15040768384, 15049154944, 15057549184, 15065939072, 15074328448, +15082715008, 15091104128, 15099493504, 15107879296, 15116269184, +15124659584, 15133042304, 15141431936, 15149824384, 15158214272, +15166602368, 15174991232, 15183378304, 15191760512, 15200154496, +15208542592, 15216931712, 15225323392, 15233708416, 15242098048, +15250489216, 15258875264, 15267265408, 15275654528, 15284043136, +15292431488, 15300819584, 15309208192, 15317596544, 15325986176, +15334374784, 15342763648, 15351151744, 15359540608, 15367929728, +15376318336, 15384706432, 15393092992, 15401481856, 15409869952, +15418258816, 15426649984, 15435037568, 15443425664, 15451815296, +15460203392, 15468589184, 15476979328, 15485369216, 15493755776, +15502146944, 15510534272, 15518924416, 15527311232, 15535699072, +15544089472, 15552478336, 15560866688, 15569254528, 15577642624, +15586031488, 15594419072, 15602809472, 15611199104, 15619586432, +15627975296, 15636364928, 15644753792, 15653141888, 15661529216, +15669918848, 15678305152, 15686696576, 15695083136, 15703474048, +15711861632, 15720251264, 15728636288, 15737027456, 15745417088, +15753804928, 15762194048, 15770582656, 15778971008, 15787358336, +15795747712, 15804132224, 15812523392, 15820909696, 15829300096, +15837691264, 15846071936, 15854466944, 15862855808, 15871244672, +15879634816, 15888020608, 15896409728, 15904799104, 15913185152, +15921577088, 15929966464, 15938354816, 15946743424, 15955129472, +15963519872, 15971907968, 15980296064, 15988684928, 15997073024, +16005460864, 16013851264, 16022241152, 16030629248, 16039012736, +16047406976, 16055794816, 16064181376, 16072571264, 16080957824, +16089346688, 16097737856, 16106125184, 16114514816, 16122904192, +16131292544, 16139678848, 16148066944, 16156453504, 16164839552, +16173236096, 16181623424, 16190012032, 16198401152, 16206790528, +16215177344, 16223567744, 16231956352, 16240344704, 16248731008, +16257117824, 16265504384, 16273898624, 16282281856, 16290668672, +16299064192, 16307449216, 16315842176, 16324230016, 16332613504, +16341006464, 16349394304, 16357783168, 16366172288, 16374561664, +16382951296, 16391337856, 16399726208, 16408116352, 16416505472, +16424892032, 16433282176, 16441668224, 16450058624, 16458448768, +16466836864, 16475224448, 16483613056, 16492001408, 16500391808, +16508779648, 16517166976, 16525555328, 16533944192, 16542330752, +16550719616, 16559110528, 16567497088, 16575888512, 16584274816, +16592665472, 16601051008, 16609442944, 16617832064, 16626218624, +16634607488, 16642996096, 16651385728, 16659773824, 16668163712, +16676552576, 16684938112, 16693328768, 16701718144, 16710095488, +16718492288, 16726883968, 16735272832, 16743661184, 16752049792, +16760436608, 16768827008, 16777214336, 16785599104, 16793992832, +16802381696, 16810768768, 16819151744, 16827542656, 16835934848, +16844323712, 16852711552, 16861101952, 16869489536, 16877876864, +16886265728, 16894653056, 16903044736, 16911431296, 16919821696, +16928207488, 16936592768, 16944987776, 16953375616, 16961763968, +16970152832, 16978540928, 16986929536, 16995319168, 17003704448, +17012096896, 17020481152, 17028870784, 17037262208, 17045649536, +17054039936, 17062426496, 17070814336, 17079205504, 17087592064, +17095978112, 17104369024, 17112759424, 17121147776, 17129536384, +17137926016, 17146314368, 17154700928, 17163089792, 17171480192, +17179864192, 17188256896, 17196644992, 17205033856, 17213423488, +17221811072, 17230198912, 17238588032, 17246976896, 17255360384, +17263754624, 17272143232, 17280530048, 17288918912, 17297309312, +17305696384, 17314085504, 17322475136, 17330863744, 17339252096, +17347640192, 17356026496, 17364413824, 17372796544, 17381190016, +17389583488, 17397972608, 17406360704, 17414748544, 17423135872, +17431527296, 17439915904, 17448303232, 17456691584, 17465081728, +17473468288, 17481857408, 17490247552, 17498635904, 17507022464, +17515409024, 17523801728, 17532189824, 17540577664, 17548966016, +17557353344, 17565741184, 17574131584, 17582519168, 17590907008, +17599296128, 17607687808, 17616076672, 17624455808, 17632852352, +17641238656, 17649630848, 17658018944, 17666403968, 17674794112, +17683178368, 17691573376, 17699962496, 17708350592, 17716739968, +17725126528, 17733517184, 17741898112, 17750293888, 17758673024, +17767070336, 17775458432, 17783848832, 17792236928, 17800625536, +17809012352, 17817402752, 17825785984, 17834178944, 17842563968, +17850955648, 17859344512, 17867732864, 17876119424, 17884511872, +17892900224, 17901287296, 17909677696, 17918058112, 17926451072, +17934843776, 17943230848, 17951609216, 17960008576, 17968397696, +17976784256, 17985175424, 17993564032, 18001952128, 18010339712, +18018728576, 18027116672, 18035503232, 18043894144, 18052283264, +18060672128, 18069056384, 18077449856, 18085837184, 18094225792, +18102613376, 18111004544, 18119388544, 18127781248, 18136170368, +18144558976, 18152947328, 18161336192, 18169724288, 18178108544, +18186498944, 18194886784, 18203275648, 18211666048, 18220048768, +18228444544, 18236833408, 18245220736] + +cache_sizes = [ +16776896, 16907456, 17039296, 17170112, 17301056, 17432512, 17563072, +17693888, 17824192, 17955904, 18087488, 18218176, 18349504, 18481088, +18611392, 18742336, 18874304, 19004224, 19135936, 19267264, 19398208, +19529408, 19660096, 19791424, 19922752, 20053952, 20184896, 20315968, +20446912, 20576576, 20709184, 20840384, 20971072, 21102272, 21233216, +21364544, 21494848, 21626816, 21757376, 21887552, 22019392, 22151104, +22281536, 22412224, 22543936, 22675264, 22806464, 22935872, 23068096, +23198272, 23330752, 23459008, 23592512, 23723968, 23854912, 23986112, +24116672, 24247616, 24378688, 24509504, 24640832, 24772544, 24903488, +25034432, 25165376, 25296704, 25427392, 25558592, 25690048, 25820096, +25951936, 26081728, 26214208, 26345024, 26476096, 26606656, 26737472, +26869184, 26998208, 27131584, 27262528, 27393728, 27523904, 27655744, +27786688, 27917888, 28049344, 28179904, 28311488, 28441792, 28573504, +28700864, 28835648, 28966208, 29096768, 29228608, 29359808, 29490752, +29621824, 29752256, 29882816, 30014912, 30144448, 30273728, 30406976, +30538432, 30670784, 30799936, 30932672, 31063744, 31195072, 31325248, +31456192, 31588288, 31719232, 31850432, 31981504, 32110784, 32243392, +32372672, 32505664, 32636608, 32767808, 32897344, 33029824, 33160768, +33289664, 33423296, 33554368, 33683648, 33816512, 33947456, 34076992, +34208704, 34340032, 34471744, 34600256, 34734016, 34864576, 34993984, +35127104, 35258176, 35386688, 35518528, 35650624, 35782336, 35910976, +36044608, 36175808, 36305728, 36436672, 36568384, 36699968, 36830656, +36961984, 37093312, 37223488, 37355072, 37486528, 37617472, 37747904, +37879232, 38009792, 38141888, 38272448, 38403392, 38535104, 38660672, +38795584, 38925632, 39059264, 39190336, 39320768, 39452096, 39581632, +39713984, 39844928, 39974848, 40107968, 40238144, 40367168, 40500032, +40631744, 40762816, 40894144, 41023552, 41155904, 41286208, 41418304, +41547712, 41680448, 41811904, 41942848, 42073792, 42204992, 42334912, +42467008, 42597824, 42729152, 42860096, 42991552, 43122368, 43253696, +43382848, 43515712, 43646912, 43777088, 43907648, 44039104, 44170432, +44302144, 44433344, 44564288, 44694976, 44825152, 44956864, 45088448, +45219008, 45350464, 45481024, 45612608, 45744064, 45874496, 46006208, +46136768, 46267712, 46399424, 46529344, 46660672, 46791488, 46923328, +47053504, 47185856, 47316928, 47447872, 47579072, 47710144, 47839936, +47971648, 48103232, 48234176, 48365248, 48496192, 48627136, 48757312, +48889664, 49020736, 49149248, 49283008, 49413824, 49545152, 49675712, +49807168, 49938368, 50069056, 50200256, 50331584, 50462656, 50593472, +50724032, 50853952, 50986048, 51117632, 51248576, 51379904, 51510848, +51641792, 51773248, 51903296, 52035136, 52164032, 52297664, 52427968, +52557376, 52690112, 52821952, 52952896, 53081536, 53213504, 53344576, +53475776, 53608384, 53738816, 53870528, 54000832, 54131776, 54263744, +54394688, 54525248, 54655936, 54787904, 54918592, 55049152, 55181248, +55312064, 55442752, 55574336, 55705024, 55836224, 55967168, 56097856, +56228672, 56358592, 56490176, 56621888, 56753728, 56884928, 57015488, +57146816, 57278272, 57409216, 57540416, 57671104, 57802432, 57933632, +58064576, 58195264, 58326976, 58457408, 58588864, 58720192, 58849984, +58981696, 59113024, 59243456, 59375552, 59506624, 59637568, 59768512, +59897792, 60030016, 60161984, 60293056, 60423872, 60554432, 60683968, +60817216, 60948032, 61079488, 61209664, 61341376, 61471936, 61602752, +61733696, 61865792, 61996736, 62127808, 62259136, 62389568, 62520512, +62651584, 62781632, 62910784, 63045056, 63176128, 63307072, 63438656, +63569216, 63700928, 63831616, 63960896, 64093888, 64225088, 64355392, +64486976, 64617664, 64748608, 64879424, 65009216, 65142464, 65273792, +65402816, 65535424, 65666752, 65797696, 65927744, 66060224, 66191296, +66321344, 66453056, 66584384, 66715328, 66846656, 66977728, 67108672, +67239104, 67370432, 67501888, 67631296, 67763776, 67895104, 68026304, +68157248, 68287936, 68419264, 68548288, 68681408, 68811968, 68942912, +69074624, 69205568, 69337024, 69467584, 69599168, 69729472, 69861184, +69989824, 70122944, 70253888, 70385344, 70515904, 70647232, 70778816, +70907968, 71040832, 71171648, 71303104, 71432512, 71564992, 71695168, +71826368, 71958464, 72089536, 72219712, 72350144, 72482624, 72613568, +72744512, 72875584, 73006144, 73138112, 73268672, 73400128, 73530944, +73662272, 73793344, 73924544, 74055104, 74185792, 74316992, 74448832, +74579392, 74710976, 74841664, 74972864, 75102784, 75233344, 75364544, +75497024, 75627584, 75759296, 75890624, 76021696, 76152256, 76283072, +76414144, 76545856, 76676672, 76806976, 76937792, 77070016, 77200832, +77331392, 77462464, 77593664, 77725376, 77856448, 77987776, 78118336, +78249664, 78380992, 78511424, 78642496, 78773056, 78905152, 79033664, +79166656, 79297472, 79429568, 79560512, 79690816, 79822784, 79953472, +80084672, 80214208, 80346944, 80477632, 80608576, 80740288, 80870848, +81002048, 81133504, 81264448, 81395648, 81525952, 81657536, 81786304, +81919808, 82050112, 82181312, 82311616, 82443968, 82573376, 82705984, +82835776, 82967744, 83096768, 83230528, 83359552, 83491264, 83622464, +83753536, 83886016, 84015296, 84147776, 84277184, 84409792, 84540608, +84672064, 84803008, 84934336, 85065152, 85193792, 85326784, 85458496, +85589312, 85721024, 85851968, 85982656, 86112448, 86244416, 86370112, +86506688, 86637632, 86769344, 86900672, 87031744, 87162304, 87293632, +87424576, 87555392, 87687104, 87816896, 87947968, 88079168, 88211264, +88341824, 88473152, 88603712, 88735424, 88862912, 88996672, 89128384, +89259712, 89390272, 89521984, 89652544, 89783872, 89914816, 90045376, +90177088, 90307904, 90438848, 90569152, 90700096, 90832832, 90963776, +91093696, 91223744, 91356992, 91486784, 91618496, 91749824, 91880384, +92012224, 92143552, 92273344, 92405696, 92536768, 92666432, 92798912, +92926016, 93060544, 93192128, 93322816, 93453632, 93583936, 93715136, +93845056, 93977792, 94109504, 94240448, 94371776, 94501184, 94632896, +94764224, 94895552, 95023424, 95158208, 95287744, 95420224, 95550016, +95681216, 95811904, 95943872, 96075328, 96203584, 96337856, 96468544, +96599744, 96731072, 96860992, 96992576, 97124288, 97254848, 97385536, +97517248, 97647808, 97779392, 97910464, 98041408, 98172608, 98303168, +98434496, 98565568, 98696768, 98827328, 98958784, 99089728, 99220928, +99352384, 99482816, 99614272, 99745472, 99876416, 100007104, +100138048, 100267072, 100401088, 100529984, 100662592, 100791872, +100925248, 101056064, 101187392, 101317952, 101449408, 101580608, +101711296, 101841728, 101973824, 102104896, 102235712, 102366016, +102498112, 102628672, 102760384, 102890432, 103021888, 103153472, +103284032, 103415744, 103545152, 103677248, 103808576, 103939648, +104070976, 104201792, 104332736, 104462528, 104594752, 104725952, +104854592, 104988608, 105118912, 105247808, 105381184, 105511232, +105643072, 105774784, 105903296, 106037056, 106167872, 106298944, +106429504, 106561472, 106691392, 106822592, 106954304, 107085376, +107216576, 107346368, 107478464, 107609792, 107739712, 107872192, +108003136, 108131392, 108265408, 108396224, 108527168, 108657344, +108789568, 108920384, 109049792, 109182272, 109312576, 109444928, +109572928, 109706944, 109837888, 109969088, 110099648, 110230976, +110362432, 110492992, 110624704, 110755264, 110886208, 111017408, +111148864, 111279296, 111410752, 111541952, 111673024, 111803456, +111933632, 112066496, 112196416, 112328512, 112457792, 112590784, +112715968, 112852672, 112983616, 113114944, 113244224, 113376448, +113505472, 113639104, 113770304, 113901376, 114031552, 114163264, +114294592, 114425536, 114556864, 114687424, 114818624, 114948544, +115080512, 115212224, 115343296, 115473472, 115605184, 115736128, +115867072, 115997248, 116128576, 116260288, 116391488, 116522944, +116652992, 116784704, 116915648, 117046208, 117178304, 117308608, +117440192, 117569728, 117701824, 117833024, 117964096, 118094656, +118225984, 118357312, 118489024, 118617536, 118749632, 118882112, +119012416, 119144384, 119275328, 119406016, 119537344, 119668672, +119798464, 119928896, 120061376, 120192832, 120321728, 120454336, +120584512, 120716608, 120848192, 120979136, 121109056, 121241408, +121372352, 121502912, 121634752, 121764416, 121895744, 122027072, +122157632, 122289088, 122421184, 122550592, 122682944, 122813888, +122945344, 123075776, 123207488, 123338048, 123468736, 123600704, +123731264, 123861952, 123993664, 124124608, 124256192, 124386368, +124518208, 124649024, 124778048, 124911296, 125041088, 125173696, +125303744, 125432896, 125566912, 125696576, 125829056, 125958592, +126090304, 126221248, 126352832, 126483776, 126615232, 126746432, +126876608, 127008704, 127139392, 127270336, 127401152, 127532224, +127663552, 127794752, 127925696, 128055232, 128188096, 128319424, +128449856, 128581312, 128712256, 128843584, 128973632, 129103808, +129236288, 129365696, 129498944, 129629888, 129760832, 129892288, +130023104, 130154048, 130283968, 130416448, 130547008, 130678336, +130807616, 130939456, 131071552, 131202112, 131331776, 131464384, +131594048, 131727296, 131858368, 131987392, 132120256, 132250816, +132382528, 132513728, 132644672, 132774976, 132905792, 133038016, +133168832, 133299392, 133429312, 133562048, 133692992, 133823296, +133954624, 134086336, 134217152, 134348608, 134479808, 134607296, +134741056, 134872384, 135002944, 135134144, 135265472, 135396544, +135527872, 135659072, 135787712, 135921472, 136052416, 136182848, +136313792, 136444864, 136576448, 136707904, 136837952, 136970048, +137099584, 137232064, 137363392, 137494208, 137625536, 137755712, +137887424, 138018368, 138149824, 138280256, 138411584, 138539584, +138672832, 138804928, 138936128, 139066688, 139196864, 139328704, +139460032, 139590208, 139721024, 139852864, 139984576, 140115776, +140245696, 140376512, 140508352, 140640064, 140769856, 140902336, +141032768, 141162688, 141294016, 141426496, 141556544, 141687488, +141819584, 141949888, 142080448, 142212544, 142342336, 142474432, +142606144, 142736192, 142868288, 142997824, 143129408, 143258944, +143392448, 143523136, 143653696, 143785024, 143916992, 144045632, +144177856, 144309184, 144440768, 144570688, 144701888, 144832448, +144965056, 145096384, 145227584, 145358656, 145489856, 145620928, +145751488, 145883072, 146011456, 146144704, 146275264, 146407232, +146538176, 146668736, 146800448, 146931392, 147062336, 147193664, +147324224, 147455936, 147586624, 147717056, 147848768, 147979456, +148110784, 148242368, 148373312, 148503232, 148635584, 148766144, +148897088, 149028416, 149159488, 149290688, 149420224, 149551552, +149683136, 149814976, 149943616, 150076352, 150208064, 150338624, +150470464, 150600256, 150732224, 150862784, 150993088, 151125952, +151254976, 151388096, 151519168, 151649728, 151778752, 151911104, +152042944, 152174144, 152304704, 152435648, 152567488, 152698816, +152828992, 152960576, 153091648, 153222976, 153353792, 153484096, +153616192, 153747008, 153878336, 154008256, 154139968, 154270912, +154402624, 154533824, 154663616, 154795712, 154926272, 155057984, +155188928, 155319872, 155450816, 155580608, 155712064, 155843392, +155971136, 156106688, 156237376, 156367424, 156499264, 156630976, +156761536, 156892352, 157024064, 157155008, 157284416, 157415872, +157545536, 157677248, 157810496, 157938112, 158071744, 158203328, +158334656, 158464832, 158596288, 158727616, 158858048, 158988992, +159121216, 159252416, 159381568, 159513152, 159645632, 159776192, +159906496, 160038464, 160169536, 160300352, 160430656, 160563008, +160693952, 160822208, 160956352, 161086784, 161217344, 161349184, +161480512, 161611456, 161742272, 161873216, 162002752, 162135872, +162266432, 162397888, 162529216, 162660032, 162790976, 162922048, +163052096, 163184576, 163314752, 163446592, 163577408, 163707968, +163839296, 163969984, 164100928, 164233024, 164364224, 164494912, +164625856, 164756672, 164887616, 165019072, 165150016, 165280064, +165412672, 165543104, 165674944, 165805888, 165936832, 166067648, +166198336, 166330048, 166461248, 166591552, 166722496, 166854208, +166985408, 167116736, 167246656, 167378368, 167508416, 167641024, +167771584, 167903168, 168034112, 168164032, 168295744, 168427456, +168557632, 168688448, 168819136, 168951616, 169082176, 169213504, +169344832, 169475648, 169605952, 169738048, 169866304, 169999552, +170131264, 170262464, 170393536, 170524352, 170655424, 170782016, +170917696, 171048896, 171179072, 171310784, 171439936, 171573184, +171702976, 171835072, 171966272, 172097216, 172228288, 172359232, +172489664, 172621376, 172747712, 172883264, 173014208, 173144512, +173275072, 173407424, 173539136, 173669696, 173800768, 173931712, +174063424, 174193472, 174325696, 174455744, 174586816, 174718912, +174849728, 174977728, 175109696, 175242688, 175374272, 175504832, +175636288, 175765696, 175898432, 176028992, 176159936, 176291264, +176422592, 176552512, 176684864, 176815424, 176946496, 177076544, +177209152, 177340096, 177470528, 177600704, 177731648, 177864256, +177994816, 178126528, 178257472, 178387648, 178518464, 178650176, +178781888, 178912064, 179044288, 179174848, 179305024, 179436736, +179568448, 179698496, 179830208, 179960512, 180092608, 180223808, +180354752, 180485696, 180617152, 180748096, 180877504, 181009984, +181139264, 181272512, 181402688, 181532608, 181663168, 181795136, +181926592, 182057536, 182190016, 182320192, 182451904, 182582336, +182713792, 182843072, 182976064, 183107264, 183237056, 183368384, +183494848, 183631424, 183762752, 183893824, 184024768, 184154816, +184286656, 184417984, 184548928, 184680128, 184810816, 184941248, +185072704, 185203904, 185335616, 185465408, 185596352, 185727296, +185859904, 185989696, 186121664, 186252992, 186383552, 186514112, +186645952, 186777152, 186907328, 187037504, 187170112, 187301824, +187429184, 187562048, 187693504, 187825472, 187957184, 188087104, +188218304, 188349376, 188481344, 188609728, 188743616, 188874304, +189005248, 189136448, 189265088, 189396544, 189528128, 189660992, +189791936, 189923264, 190054208, 190182848, 190315072, 190447424, +190577984, 190709312, 190840768, 190971328, 191102656, 191233472, +191364032, 191495872, 191626816, 191758016, 191888192, 192020288, +192148928, 192282176, 192413504, 192542528, 192674752, 192805952, +192937792, 193068608, 193198912, 193330496, 193462208, 193592384, +193723456, 193854272, 193985984, 194116672, 194247232, 194379712, +194508352, 194641856, 194772544, 194900672, 195035072, 195166016, +195296704, 195428032, 195558592, 195690304, 195818176, 195952576, +196083392, 196214336, 196345792, 196476736, 196607552, 196739008, +196869952, 197000768, 197130688, 197262784, 197394368, 197523904, +197656384, 197787584, 197916608, 198049472, 198180544, 198310208, +198442432, 198573632, 198705088, 198834368, 198967232, 199097792, +199228352, 199360192, 199491392, 199621696, 199751744, 199883968, +200014016, 200146624, 200276672, 200408128, 200540096, 200671168, +200801984, 200933312, 201062464, 201194944, 201326144, 201457472, +201588544, 201719744, 201850816, 201981632, 202111552, 202244032, +202374464, 202505152, 202636352, 202767808, 202898368, 203030336, +203159872, 203292608, 203423296, 203553472, 203685824, 203816896, +203947712, 204078272, 204208192, 204341056, 204472256, 204603328, +204733888, 204864448, 204996544, 205125568, 205258304, 205388864, +205517632, 205650112, 205782208, 205913536, 206044736, 206176192, +206307008, 206434496, 206569024, 206700224, 206831168, 206961856, +207093056, 207223616, 207355328, 207486784, 207616832, 207749056, +207879104, 208010048, 208141888, 208273216, 208404032, 208534336, +208666048, 208796864, 208927424, 209059264, 209189824, 209321792, +209451584, 209582656, 209715136, 209845568, 209976896, 210106432, +210239296, 210370112, 210501568, 210630976, 210763712, 210894272, +211024832, 211156672, 211287616, 211418176, 211549376, 211679296, +211812032, 211942592, 212074432, 212204864, 212334016, 212467648, +212597824, 212727616, 212860352, 212991424, 213120832, 213253952, +213385024, 213515584, 213645632, 213777728, 213909184, 214040128, +214170688, 214302656, 214433728, 214564544, 214695232, 214826048, +214956992, 215089088, 215219776, 215350592, 215482304, 215613248, +215743552, 215874752, 216005312, 216137024, 216267328, 216399296, +216530752, 216661696, 216790592, 216923968, 217054528, 217183168, +217316672, 217448128, 217579072, 217709504, 217838912, 217972672, +218102848, 218233024, 218364736, 218496832, 218627776, 218759104, +218888896, 219021248, 219151936, 219281728, 219413056, 219545024, +219675968, 219807296, 219938624, 220069312, 220200128, 220331456, +220461632, 220592704, 220725184, 220855744, 220987072, 221117888, +221249216, 221378368, 221510336, 221642048, 221772736, 221904832, +222031808, 222166976, 222297536, 222428992, 222559936, 222690368, +222820672, 222953152, 223083968, 223213376, 223345984, 223476928, +223608512, 223738688, 223869376, 224001472, 224132672, 224262848, +224394944, 224524864, 224657344, 224788288, 224919488, 225050432, +225181504, 225312704, 225443776, 225574592, 225704768, 225834176, +225966784, 226097216, 226229824, 226360384, 226491712, 226623424, +226754368, 226885312, 227015104, 227147456, 227278528, 227409472, +227539904, 227669696, 227802944, 227932352, 228065216, 228196288, +228326464, 228457792, 228588736, 228720064, 228850112, 228981056, +229113152, 229243328, 229375936, 229505344, 229636928, 229769152, +229894976, 230030272, 230162368, 230292416, 230424512, 230553152, +230684864, 230816704, 230948416, 231079616, 231210944, 231342016, +231472448, 231603776, 231733952, 231866176, 231996736, 232127296, +232259392, 232388672, 232521664, 232652608, 232782272, 232914496, +233043904, 233175616, 233306816, 233438528, 233569984, 233699776, +233830592, 233962688, 234092224, 234221888, 234353984, 234485312, +234618304, 234749888, 234880832, 235011776, 235142464, 235274048, +235403456, 235535936, 235667392, 235797568, 235928768, 236057152, +236190272, 236322752, 236453312, 236583616, 236715712, 236846528, +236976448, 237108544, 237239104, 237371072, 237501632, 237630784, +237764416, 237895232, 238026688, 238157632, 238286912, 238419392, +238548032, 238681024, 238812608, 238941632, 239075008, 239206336, +239335232, 239466944, 239599168, 239730496, 239861312, 239992384, +240122816, 240254656, 240385856, 240516928, 240647872, 240779072, +240909632, 241040704, 241171904, 241302848, 241433408, 241565248, +241696192, 241825984, 241958848, 242088256, 242220224, 242352064, +242481856, 242611648, 242744896, 242876224, 243005632, 243138496, +243268672, 243400384, 243531712, 243662656, 243793856, 243924544, +244054592, 244187072, 244316608, 244448704, 244580032, 244710976, +244841536, 244972864, 245104448, 245233984, 245365312, 245497792, +245628736, 245759936, 245889856, 246021056, 246152512, 246284224, +246415168, 246545344, 246675904, 246808384, 246939584, 247070144, +247199552, 247331648, 247463872, 247593536, 247726016, 247857088, +247987648, 248116928, 248249536, 248380736, 248512064, 248643008, +248773312, 248901056, 249036608, 249167552, 249298624, 249429184, +249560512, 249692096, 249822784, 249954112, 250085312, 250215488, +250345792, 250478528, 250608704, 250739264, 250870976, 251002816, +251133632, 251263552, 251395136, 251523904, 251657792, 251789248, +251919424, 252051392, 252182464, 252313408, 252444224, 252575552, +252706624, 252836032, 252968512, 253099712, 253227584, 253361728, +253493056, 253623488, 253754432, 253885504, 254017216, 254148032, +254279488, 254410432, 254541376, 254672576, 254803264, 254933824, +255065792, 255196736, 255326528, 255458752, 255589952, 255721408, +255851072, 255983296, 256114624, 256244416, 256374208, 256507712, +256636096, 256768832, 256900544, 257031616, 257162176, 257294272, +257424448, 257555776, 257686976, 257818432, 257949632, 258079552, +258211136, 258342464, 258473408, 258603712, 258734656, 258867008, +258996544, 259127744, 259260224, 259391296, 259522112, 259651904, +259784384, 259915328, 260045888, 260175424, 260308544, 260438336, +260570944, 260700992, 260832448, 260963776, 261092672, 261226304, +261356864, 261487936, 261619648, 261750592, 261879872, 262011968, +262143424, 262274752, 262404416, 262537024, 262667968, 262799296, +262928704, 263061184, 263191744, 263322944, 263454656, 263585216, +263716672, 263847872, 263978944, 264108608, 264241088, 264371648, +264501184, 264632768, 264764096, 264895936, 265024576, 265158464, +265287488, 265418432, 265550528, 265681216, 265813312, 265943488, +266075968, 266206144, 266337728, 266468032, 266600384, 266731072, +266862272, 266993344, 267124288, 267255616, 267386432, 267516992, +267648704, 267777728, 267910592, 268040512, 268172096, 268302784, +268435264, 268566208, 268696256, 268828096, 268959296, 269090368, +269221312, 269352256, 269482688, 269614784, 269745856, 269876416, +270007616, 270139328, 270270272, 270401216, 270531904, 270663616, +270791744, 270924736, 271056832, 271186112, 271317184, 271449536, +271580992, 271711936, 271843136, 271973056, 272105408, 272236352, +272367296, 272498368, 272629568, 272759488, 272891456, 273022784, +273153856, 273284672, 273415616, 273547072, 273677632, 273808448, +273937088, 274071488, 274200896, 274332992, 274463296, 274595392, +274726208, 274857536, 274988992, 275118656, 275250496, 275382208, +275513024, 275643968, 275775296, 275906368, 276037184, 276167872, +276297664, 276429376, 276560576, 276692672, 276822976, 276955072, +277085632, 277216832, 277347008, 277478848, 277609664, 277740992, +277868608, 278002624, 278134336, 278265536, 278395328, 278526784, +278657728, 278789824, 278921152, 279052096, 279182912, 279313088, +279443776, 279576256, 279706048, 279838528, 279969728, 280099648, +280230976, 280361408, 280493632, 280622528, 280755392, 280887104, +281018176, 281147968, 281278912, 281411392, 281542592, 281673152, +281803712, 281935552, 282066496, 282197312, 282329024, 282458816, +282590272, 282720832, 282853184, 282983744, 283115072, 283246144, +283377344, 283508416, 283639744, 283770304, 283901504, 284032576, +284163136, 284294848, 284426176, 284556992, 284687296, 284819264, +284950208, 285081536] +``` diff --git a/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md new file mode 100644 index 00000000000..5e33f935bd6 --- /dev/null +++ b/src/content/translations/it/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md @@ -0,0 +1,37 @@ +--- +title: Algoritmi di mining +description: Uno sguardo dettagliato agli algoritmi usati per il mining di Ethereum. +lang: it +--- + + +Il proof-of-work non è più alla base del meccanismo di consenso di Ethereum, a significare che il mining è stato disattivato. Invece, Ethereum, è protetto dai validatori che mettono ETH in staking. Puoi iniziare oggi a mettere i tuoi ETH in staking. Leggi di più su La Fusione, il proof-of-stake e lo staking. Questa pagina è per solo interesse storico. + + +Il mining di Ethereum usava un algoritmo noto come Ethash. L'idea fondamentale dell'algoritmo è che un miner prova a trovare l'input di un nonce usando il calcolo di forza bruta, così che l'hash risultante sia inferiore a una soglia determinata dalla difficoltà calcolata. Questo livello di difficoltà può esser regolato dinamicamente, consentendo alla produzione dei blocchi di verificarsi a un intervallo regolare. + +## Prerequisiti {#prerequisites} + +Per comprendere meglio questa pagina, ti consigliamo prima di leggere sul [consenso proof-of-work](/developers/docs/consensus-mechanisms/pow) e sul [mining](/developers/docs/consensus-mechanisms/pow/mining). + +## Dagger Hashimoto {#dagger-hashimoto} + +Dagger Hashimoto era un algoritmo di ricerca precursore del mining di Ethereum, sostituito da Ethash. Era un amalgama di due algoritmi differenti: Dagger e Hashimoto. È sempre e solo stato un'implementazione di ricerca e fu superato da Ethash prima del lancio della Rete Principale di Ethereum. + +[Dagger](http://www.hashcash.org/papers/dagger.html) prevede la generazione di un [Grafico Aciclico Diretto](https://en.wikipedia.org/wiki/Directed_acyclic_graph), porzioni casuali del quale ricevono un hashing insieme. Il principio fondamentale è che ogni nonce richiede solo una piccola porzione di un grande albero di dati totali. Ricalcolare l'albero secondario per ogni nonce è proibitivo per il mining, da cui l'esigenza di memorizzare l'albero, invece, va bene per verificare un singolo nonce. Dagger è stato progettato per essere un'alternativa agli algoritmi esistenti come Scrypt, che sono gravosi per la memoria (memory-hard) ma difficili da verificare all'aumentare dell'uso della memoria verso livelli veramente sicuri. Dagger era però vulnerabile all'accelerazione dell'hardware con memoria condiviso ed è stato abbandonato a favore di altre vie di ricerca. + +[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) è un algoritmo che aggiunge resistenza ASIC, essendo vincolato da aspetti I/O (cioè le letture di memoria rappresentano il fattore limitante nel processo di mining). La teoria è che vi sia più disponibilità di RAM che di calcolo: sono già stati usati miliardi di dollari in ricerca per l'ottimizzazione della RAM per diversi scenari d'uso, che spesso coinvolgono schemi d'accesso semi-casuale (da cui "memoria d'accesso casuale", Random Access Memory). Di conseguenza, è probabile che la RAM esistente sia abbastanza vicina all'ottimale per valutare l'algoritmo. Hashimoto usa la blockchain come una fonte di dati, perché soddisfa simultaneamente i punti (1) e (3) di cui sopra. + +Dagger-Hashimoto usava delle versioni modificate degli algoritmi di Dagger e Hashimoto. La differenza tra Dagger Hashimoto e Hashimoto è che, anziché usare la blockchain come una fonte di dati, Dagger Hashimoto usa una serie di dati generata e personalizzata, che si aggiorna a seconda dei dati del blocco ogni N blocchi. La serie di dati è generata usando l'algoritmo di Dagger, che consente di calcolare efficientemente una sotto-serie specifica a ogni nonce per l'algoritmo di verifica del client leggero. La differenza tra Dagger Hashimoto e Dagger è che, a differenza del Dagger originale, il dataset usato per interrogare il blocco è semi-permanente, in quanto viene aggiornato solo occasionalmente (es. una volta a settimana). Questo significa che la porzione dello sforzo per generare il dataset è prossima allo zero, e diventano quindi trascurabili gli argomenti di Sergio Lerner riguardanti le velocizzazioni della memoria condivisa. + +Maggiori informazioni su [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto). + +## Ethash {#ethash} + +Ethash era l'algoritmo di mining che era effettiamente usato sulla vera Rete Principale di Ethereum sotto l'ora deprecata architettura del proof-of-work. Ethash in realtà è un nuovo nome assegnato a una versione specifica di Dagger-Hashimoto dopo un aggiornamento significativo dell'algoritmo, che comunque eredita i principi fondamentali del suo predecessore. La Rete Principale di Ethereum ha sempre e solo usato Ethash; Dagger Hashimoto era una versione R&D dell'algoritmo di mining che fu superata prima che il mining fosse avviato sulla rete principale di Ethereum. + +[Maggiori informazioni su Ethash](/developers/docs/consensus-mechanisms/pow/mining-algorithms/ethash). + +## Letture consigliate {#further-reading} + +_Conosci una risorsa della community che ti è stata utile? Modifica questa pagina e aggiungila!_ diff --git a/src/content/translations/it/developers/docs/data-and-analytics/block-explorers/index.md b/src/content/translations/it/developers/docs/data-and-analytics/block-explorers/index.md index dbb37c79de5..3b47068bf31 100644 --- a/src/content/translations/it/developers/docs/data-and-analytics/block-explorers/index.md +++ b/src/content/translations/it/developers/docs/data-and-analytics/block-explorers/index.md @@ -14,12 +14,15 @@ I block explorer sono il tuo portale sui dati di Ethereum. Puoi usarli per visua ## Servizi {#services} - [Etherscan](https://etherscan.io/): _disponibile anche in cinese, coreano, russo e giapponese_ -- [Etherchain](https://www.etherchain.org/) -- [Ethplorer](https://ethplorer.io/): _disponibile anche in cinese, spagnolo, francese, turco, russo, coreano e vietnamita_ +- [Beaconcha.in](https://beaconcha.in/) - [Blockchair](https://blockchair.com/ethereum): _disponibile anche in spagnolo, francese, italiano, olandese, portoghese, russo, cinese e farsi_ - [Blockscout](https://blockscout.com/) +- [Etherchain](https://www.etherchain.org/) +- [Ethplorer](https://ethplorer.io/): _disponibile anche in cinese, spagnolo, francese, turco, russo, coreano e vietnamita_ - [OKLink](https://www.oklink.com/eth) - [Otterscan](https://otterscan.io/) +- [Sirato](https://www.web3labs.com/sirato) +- [EthVM](https://www.ethvm.com/) ## Dati {#data} @@ -226,10 +229,11 @@ I dati di livello superiore del livello di consenso includono quanto segue: ## Block explorer {#block-explorers} -- [Etherscan](https://etherscan.io/) - un esploratore di blocchi che puoi usare per recuperare i dati per la Rete Principale di Ethereum e le Reti di Prova di Ropsten, Kovan, Rinkeby e Goerli -- [Etherchain](https://www.etherchain.org/) - un esploratore di blocchi per la Rete Principale di Ethereum -- [Ethplorer](https://ethplorer.io/) - un esploratore di blocchi incentrato sui token per la Rete Principale di Ethereum e la rete di prova di Kovan +- [Etherscan](https://etherscan.io/) - un esploratore di blocchi che puoi usare per recuperare i dati per la Rete Principale di Ethereum e le reti di prova di Ropsten, Kovan, Rinkeby e Goerli +- [Beaconcha.in](https://beaconcha.in/) - un esploratore di blocchi open source per la Rete Principale di Ethereum e la rete di prova di Goerli - [Blockchair](https://blockchair.com/ethereum): l'esploratore di Ethereum più privato. Anche per ordinare e filtrare i dati (mempool) +- [Etherchain](https://www.etherchain.org/) - un esploratore di blocchi per la rete principale di Ethereum +- [Ethplorer](https://ethplorer.io/) - un esploratore di blocchi incentrato sui token per la Rete Principale di Ethereum e la rete di prova di Kovan ## Approfondimenti {#further-reading} diff --git a/src/content/translations/it/developers/docs/data-and-analytics/index.md b/src/content/translations/it/developers/docs/data-and-analytics/index.md index b090a778a21..4004c847d85 100644 --- a/src/content/translations/it/developers/docs/data-and-analytics/index.md +++ b/src/content/translations/it/developers/docs/data-and-analytics/index.md @@ -20,7 +20,7 @@ In termini di fondamenti architettonici, occorre comprendere che cosa sono le [A Molti [Esploratori di Blocchi](/developers/docs/data-and-analytics/block-explorers/) offrono gateway dell'[API](https://www.wikipedia.org/wiki/API) di [RESTful](https://www.wikipedia.org/wiki/Representational_state_transfer), che forniranno visibilità agli sviluppatori in dati in tempo reale sui blocchi, le transazioni, i miner, i conti e altra attività sulla catena. -Gli sviluppatori possono quindi elaborare e trasformare questi dati per fornire agli utenti informazioni e interazioni uniche con la blockchain [](/glossary/#blockchain). Ad esempio, [Etherscan](etherscan.io) fornisce i dati d'esecuzione e consenso per ogni slot di 12s. +Gli sviluppatori possono quindi elaborare e trasformare questi dati per fornire agli utenti informazioni e interazioni uniche con la blockchain [](/glossary/#blockchain). Ad esempio, [Etherscan](https://etherscan.io) fornisce i dati d'esecuzione e consenso per ogni slot di 12 secondi. ## The Graph {#the-graph} @@ -30,7 +30,7 @@ Usando [GraphQL](https://graphql.org/), gli sviluppatori possono interrogare una ## Diversità dei client -La [diversità dei client](/developers/docs/nodes-and-clients/client-diversity/) è importante per la salute complessiva della rete di Ethereum, poiché fornisce resilienza a bug ed exploit. Al momento esistono numerosi pannelli di controllo della diversità dei client, tra cui [clientdiversity.org](https://clientdiversity.org/), [rated.network](rated.network), [execution-diversity.info](https://execution-diversity.info/) e [Ethernodes](https://ethernodes.org/). +La [diversità dei client](/developers/docs/nodes-and-clients/client-diversity/) è importante per la salute complessiva della rete di Ethereum, poiché fornisce resilienza a bug ed exploit. Attualmente esistono vari pannelli di controllo della diversità del client, tra cui [clientdiversity.org](https://clientdiversity.org/), [rated.network](rated.network), [execution-diversity.info](https://execution-diversity.info/) ed [Ethernodes](https://ethernodes.org/). ## Dune Analytics {#dune-analytics} diff --git a/src/content/translations/it/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md b/src/content/translations/it/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md index 7c66cdb4adb..68e8d93143f 100644 --- a/src/content/translations/it/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md +++ b/src/content/translations/it/developers/docs/data-structures-and-encoding/patricia-merkle-trie/index.md @@ -1,32 +1,33 @@ --- -title: Alberi di Patricia Merkle -description: Introduzione ai Trie di Patricia Merkle. +title: Trie di Patricia Merkle +description: Introduzione al Trie di Patricia Merkle. lang: it sidebarDepth: 2 --- -Un Trie di Patricia Merkle fornisce una struttura di dati autenticata crittograficamente, utilizzabile per memorizzare tutte le coppie `(chiave, valore) `. +Un Trie di Patricia Merkle fornisce una struttura di dati autenticata crittograficamente, utilizzabile per memorizzare tutte le associazioni `(key, value)` (chiave, valore). -I Trie di Patricia Merkle sono completamente deterministici, quindi è garantito che un trie con le stesse coppie `(chiave, valore)` sia identico, fino all'ultimo byte. Ciò significa che hanno lo stesso hash di root, fornendo così il sacro graal dell'efficienza di `O(log(n))` per inserimenti, ricerche ed eliminazioni. Inoltre, sono più semplici da comprendere e programmare rispetto ad alternative più complesse basate sul confronto, come gli alberi rosso-neri. +I Trie di Patricia Merkle sono interamente deterministici, a significare che è garantito che degli alberi con le stesse associazioni `(key, value)` siano identici, fino all'ultimo byte. Ciò significa che hanno lo stesso hash di root, fornendo il Sacro Graal dell'efficienza di `O(log(n))` per inserimenti, ricerche ed eliminazioni. Inoltre, sono più semplici da comprendere e programmare rispetto alle più complesse alternative basate sul confronto, come gli alberi rosso-nero. ## Prerequisiti {#prerequisites} -Per comprendere questa pagina è utile avere una conoscenza di base degli alberi di Merkle e della serializzazione. +Per meglio comprendere questa pagina, sarebbe utile avere una conoscenza di base di [hash](https://en.wikipedia.org/wiki/Hash_function), [alberi di Merkle](https://en.wikipedia.org/wiki/Merkle_tree), [trie](https://en.wikipedia.org/wiki/Trie) e [serializzazione](https://en.wikipedia.org/wiki/Serialization). ## Trie della radice di base {#basic-radix-tries} In un trie della radice di base, ogni nodo si presenta così: ``` - [i0, i1 ... in, value] - + [i_0, i_1 ... i_n, value] ``` -Dove `i0 ... in` rappresenta i simboli dell'alfabeto (spesso binari o esadecimali), `value` è il valore terminale al nodo e i valori negli slot `i0 ... in` sono `NULL` o puntatori ad (nel nostro caso, hash di) altri nodi. Questo forma un'archiviazione di base `(chiave, valore)`. Ad esempio, se sei interessato al valore correntemente mappato a `dog` nel trie, prima devi convertire `dog` in lettere dell'alfabeto (ottenendo `64 6f 67`) e poi scendere dal trie seguendo il percorso, fino a trovare il valore. Dunque, prima dovresti cercare l'hash della radice in un DB flat chiave/valore per trovare il nodo di root del trie (che è un insieme di chiavi ad altri nodi), usando come chiave il valore all'indice `6` (cercando nel DB chiave/valore) per ottenere il nodo al livello inferiore successivo, poi dovresti selezionarne l'indice `4` per cercare il valore successivo, poi prendere l'indice `6` e così via, finché, una volta seguito il percorso: `root -> 6 -> 4 -> 6 -> 15 -> 6 -> 7`, dovresti leggere il valore che hai e restituire il risultato. +Dove `i_0 ... i_n` rappresenta i simboli dell'alfabeto (spesso binari o esadecimali), `value` è il valore terminale al nodo e i valori negli spazi `i_0, i_1 ... i_n` sono `NULL` o puntano ad (nel nostro caso, a hash di) altri nodi. Questo forma un'archiviazione di base `(chiave, valore)`. + +Ipotizziamo che si voglia utilizzare una struttura dei dati ad albero radicato per perdurare un ordine su una serie di coppie chiave-valore. Per trovare il valore attualmente mappato alla chiave `dog` nell'albero, occorre convertire prima `dog` in lettere dell'alfabeto (restituendo `64 6f 67`) e poi discendere l'albero seguendo tale percorso, fino a trovare il valore. Quindi, iniziare guardando l'hash radice in un database chiave/valore piatto per trovare il nodo radice dell'albero. È rappresentato come un insieme di chiavi che puntano ad altri nodi. Occorre utilizzare il valore all'indice `6` come una chiave e cercarlo nel database chiave/valore piatto per ottenere il nodo al livello inferiore. Poi si deve scegliere l'indice `4` per cercare il valore successivo, quindi, l'indice `6` e così via, finché, una volta seguito il percorso: `root -> 6 -> 4 -> 6 -> 15 -> 6 -> 7` si cerca il valore del nodo e si trova il risultato. Esiste una differenza tra cercare qualcosa nel 'trie' e nel 'DB' flat chiave/valore sottostante. Entrambi definiscono degli schemi chiave/valori, ma il DB sottostante può effettuare una tradizionale ricerca di una chiave in 1 passaggio. Cercare una chiave nel trie richiede diverse ricerche DB sottostanti, per ottenere il valore finale descritto sopra. Facciamo riferimento a quest'ultimo come `path`, per eliminare ogni ambiguità. -Le operazioni di aggiornamento ed eliminazione per i trie di radice sono semplici e possono essere approssimativamente così definite: +Le operazioni di aggiornamento ed eliminazione per gli alberi radicati sono definibili come segue: ``` def update(node,path,value): @@ -54,37 +55,39 @@ Le operazioni di aggiornamento ed eliminazione per i trie di radice sono semplic newindex = delete(curnode[path[0]],path[1:]) newnode[path[0]] = newindex - if len(filter(x -> x is not NULL, newnode)) == 0: + if all(x is NULL for x in newnode): return NULL else: db.put(hash(newnode),newnode) return hash(newnode) ``` -La parte "Merkle" del trie della radice nasce dal fatto che, come puntatore al nodo, è usato un hash crittografico deterministico di un nodo (per ogni ricerca nel DB chiave/valore `key == keccak256(rlp(value))`, piuttosto che una qualche posizione della memoria a 32 o 64 bit, come potrebbe avvenire in un trie più tradizionale implementato in C. Questo fornisce una forma d'autenticazione crittografica alla struttura dei dati; se l'hash della radice di un dato trie è pubblicamente noto, allora chiunque può fornire una prova che il trie abbia un dato valore a un percorso specifico, fornendo gli hash di ogni nodo che si unisce a un valore specifico alla radice dell'albero. È impossibile per un utente malevolo fornire una prova di una coppia (percorso, valore) che non esiste, poiché l'hash della radice è basato in definitiva su tutti gli hash successivi, quindi, ogni modifica modificherebbe l'hash della radice. +Un albero Radicato di "Merkle" è costruito collegando i nodi utilizzando sinossi di hash crittografici generati deterministicamente. Questo indirizzamento dei contenuti (nel database chiave/valore `key == keccak256(rlp(value))`) fornisce l'autenticazione crittografica dei dati archiviati. Se l'hash radice di un dato albero è noto pubblicamente, allora chiunque può fornire una prova che l'albero includa un dato valore in un percorso specifico, fornendo gli hash di ogni nodo che unisce un valore specifico alla radice dell'albero. + +È impossibile, per un utente malevolo, fornire una prova di una coppia `(percorso, valore)` che non esiste, poiché l'hash radice in definitiva si basa su tutti gli hash inferiori. Qualsiasi modifica sottostante modificherebbe l'hash radice. -Pur attraversando un percorso un nibble alla volta, come descritto sopra, gran parte dei nodi contiene un insieme di 17 elementi. Un indice per ogni possibile valore tenuto dal carattere esadecimale successivo (nibble) nel percorso e uno per detenere il valore di destinazione finale se il percorso è stato attraversato interamente. Questi nodi dell'array di 17 elementi sono detti nodi del `branch`. +Chiameremo "nibble" l'unità atomica di un albero radicato (es., un singolo carattere esadecimale o un numero binario a 4 bit). Attraversando un percorso un "nibble" per volta, come descritto sopra, i nodi possono fare riferimento massimale a 16 figli, ma includono un elemento `value`. Dunque, li rappresentiamo come un insieme di lunghezza 17. Chiamiamo questi insiemi da 17 elementi "nodi ramo". ## Trie di Patricia Merkle {#merkle-patricia-trees} -I trie della radice presentano però una grande limitazione: sono inefficienti. Se si vuole memorizzare solo una coppia (percorso, valore) in cui si trova il percorso (nel caso del trie di stato di Ethereum), lunga 64 caratteri (numero di nibble in `bytes32`), servirà oltre un kilobyte di spazio aggiuntivo per memorizzare un livello per carattere, e per ogni ricerca o eliminazione verranno eseguiti tutti i 64 passaggi. Il trie di Patricia risolve questo problema. +Gli alberi radicati hanno una grande limitazione: non sono efficienti. Se si desidera memorizzare una coppia `(percorso, valore)` dove il percorso, come in Ethereum, è lungo 64 caratteri (il numero di "nibble" in `bytes32`), servirà oltre un kilobyte di spazio aggiuntivo per memorizzare un livello per carattere e, ogni ricerca o eliminazione, richiederebbe tutti e 64 i passaggi. L'albero di Patricia introdotto di seguito risolve tale problema. ### Ottimizzazione {#optimization} -I trie di Patricia Merkle risolvono il problema d'inefficienza aggiungendo una certa complessità aggiuntiva alla struttura dei dati. Un nodo in un trie di Patricia Merkle è uno dei seguenti: +Un nodo in un trie di Patricia Merkle è uno dei seguenti: 1. `NULL` (rappresentato come la stringa vuota) 2. `branch` Un nodo da 17 elementi `[ v0 ... v15, vt ]` 3. `leaf` Un nodo da 2 elementi `[ encodedPath, value ]` 4. `extension` Un nodo da 2 elementi `[ encodedPath, key ]` -Con i percorsi da 64 caratteri è inevitabile che dopo aver attraversato i primi pochi livelli del trie, si raggiunge un nodo privo di alcun percorso divergente per almeno parte del percorso. Sarebbe ingenuo richiedere che un nodo simile abbia valori vuoti in ogni indice (uno per ognuno dei 16 caratteri esadecimali), oltre all'indice di destinazione (accanto al nibble nel percorso). Al contrario, accorciamo la discesa configurando un nodo `extension` con la forma `[ encodedPath, key ]`, in cui `encodedPath` contiene il "percorso parziale" per saltare avanti (usando la codifica compatta sopra descritta) e la `key` è per la prossima ricerca DB. +Con i percorsi da 64 caratteri è inevitabile che dopo aver attraversato i primi pochi livelli del trie, si raggiunge un nodo privo di alcun percorso divergente per almeno parte del percorso. Per evitare di dover creare 15 nodi `NULL` sparsi lungo il percorso, abbreviamo la discesa configurando un nodo `extension` della forma `[ encodedPath, key ]`, in cui `encodedPath` contiene il "percorso parziale" a cui saltare (utilizzando una codifica compatta spiegata di seguito) e `key` è per la prossima ricerca sul database. -Nel caso di un nodo `leaf`, determinabile da un flag nel primo nibble di `encodedPath`, si verifica la suddetta situazione e anche il "percorso parziale" per saltare avanti completa la restante parte di un percorso. In questo caso, `value` è lo stesso valore di destinazione. +Per un nodo `leaf`, contrassegnabile da un flag nel primo nibble del `encodedPath`, il percorso codifica tutti i frammenti precedenti del percorso del nodo e possiamo cercare direttamente il `value`. -Questa ottimizzazione introduce però delle ambiguità. +Tale suddetta ottimizzazione, tuttavia, introduce delle ambiguità. -Attraversando i percorsi in nibble, potremmo finire con un numero dispari di nibble da attraversare, ma poiché tutti i dati sono memorizzati nel formato `bytes`, non è possibile distinguere, ad esempio, tra il nibble `1` e i nibble `01` (entrambi devono essere memorizzati come `<01>`). Per specificare una lunghezza dispari, il percorso parziale è prefissato con un flag. +Attraversando i percorsi in "nibble", potremmo finire con un numero dispari di nibble da attraversare; questo perché tutti i dati sono memorizzati nel fromato `bytes`. Non è possibile differenziare tra, ad esempio, il nibble `1` e i nibble `01` (entrambi devono essere memorizzati come `<01>`). Per specificare una lunghezza dispari, il percorso parziale è prefissato con un flag. ### Specifica: codifica compatta della sequenza esadecimale con terminatore facoltativo {#specification} @@ -178,7 +181,7 @@ Ora, costruiamo un trie di questo tipo con le seguenti coppie chiave/valore nel hashE: [ <17>, [ <>, <>, <>, <>, <>, <>, [ <35>, 'coin' ], <>, <>, <>, <>, <>, <>, <>, <>, <>, 'puppy' ] ] ``` -Quando in un nodo si fa riferimento a un altro nodo, viene inserito `H(rlp.encode(x))`, dove `H(x) = keccak256(x) if len(x) >= 32 else x` e `rlp.encode` è la funzione di codifica [RLP](/fundamentals/rlp). +Quando in un nodo si fa riferimento a un altro nodo, viene inserito `H(rlp.encode(x))`, dove `H(x) = keccak256(x) if len(x) >= 32 else x` e `rlp.encode` è la funzione di codifica [RLP](/developers/docs/data-structures-and-encoding/rlp). Nota che, aggiornando un trie, si deve memorizzare la coppia chiave/valore `(keccak256(x), x)` in una tabella di ricerca persistente _se_ il nodo appena creato ha una lunghezza >= 32. Se invece il nodo è inferiore a questo valore, non è necessario memorizzare nulla, poiché la funzione f(x) = x è reversibile. @@ -194,11 +197,11 @@ Dall'intestazione di un blocco ci sono 3 radici provenienti da 3 di questi trie. ### Trie di Stato {#state-trie} -Esiste un trie di stato globale che si aggiorna nel tempo. In esso, un `path` è sempre: `keccak256(ethereumAddress)` e un `value` è sempre: `rlp(ethereumAccount)`. Più nello specifico, un `account` di Ethereum è un insieme di 4 elementi di `[nonce,balance,storageRoot,codeHash]`. A questo punto, vale la pena di notare che questo `storageRoot` è la radice di un altro trie di Patricia: +Esiste un albero di stato globale ed è aggiornato ogni volta che un client elabora un blocco. In esso, un `path` è sempre: `keccak256(ethereumAddress)` e un `value` è sempre: `rlp(ethereumAccount)`. Più nello specifico, un `account` di Ethereum è un insieme di 4 elementi di `[nonce,balance,storageRoot,codeHash]`. A questo punto, vale la pena di notare che tale `storageRoot` è la radice di un altro albero di Patricia: ### Trie d'archiviazione {#storage-trie} -Il trie d'archiviazione è dove risiedono _tutti_ i dati del contratto. Esiste un trie d'archiviazione distinto per ogni conto. Per recuperare i valori a posizioni d'archiviazione specifiche a un dato indirizzo, servono l'indirizzo d'archiviazione, la posizione intera dei dati memorizzati in archiviazione e l'ID del blocco. Questi possono poi essere passati come argomenti al `eth_getStorageAt`, definito nell'API JSON-RPC, es. per recuperare i dati allo slot d'archiviazione 0 per l'indirizzo `0x295a70b2de5e3953354a6a8344e616ed314d7251`: +Il trie d'archiviazione è dove risiedono _tutti_ i dati del contratto. Esiste un albero d'archiviazione separato per ogni conto. Per recuperare i valori a posizioni d'archiviazione specifiche a un dato indirizzo, servono l'indirizzo d'archiviazione, la posizione intera dei dati memorizzati in archiviazione e l'ID del blocco. Questi possono essere passati come argomenti al `eth_getStorageAt`, definito nell'APi di JSON-RPC, es., per recuperare i dati nello slot 0 d'archiviazione per l'indirizzo `0x295a70b2de5e3953354a6a8344e616ed314d7251`: ``` curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545 @@ -209,8 +212,8 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [ Il recupero di altri elementi in archiviazione è lievemente più impegnativo, poiché deve essere calcolata prima la posizione nel trie d'archiviazione. La posizione è calcolata come l'hash `keccak256` dell'indirizzo e della posizione d'archiviazione, entrambi con padding di zeri a sinistra, fino a una lunghezza di 32 byte. Ad esempio, la posizione dei dati nello slot d'archiviazione 1 per l'indirizzo `0x391694e7e0b0cce554cb130d723a9d27458f9298` è: -```keccak256(decodeHex("000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001")) - +``` +keccak256(decodeHex("000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001")) ``` In una console Geth, si può calcolare in questo modo: @@ -232,7 +235,7 @@ curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": [ ### Trie delle transazioni {#transaction-trie} -Esiste un trie delle transazioni distinto per ogni blocco, che memorizza ancora coppie (chiave, valore). Qui, un percorso è: rlp(transactionIndex) che rappresenta la chiave corrispondente a un valore determinato da: +Esiste un albero di transazioni separato per ogni blocco, anch'esso che memorizza coppie `(key, value)`. Qui, un percorso è: `rlp(transactionIndex)`, rappresentante la chiave corrispondente a un valore determinato da: ``` if legacyTx: @@ -245,11 +248,12 @@ Maggiori informazioni a riguardo si possono trovare nella documentazione [EIP 27 ### Trie delle ricevute {#receipts-trie} -Ogni blocco ha il proprio trie delle ricevute. Qui, un `path` è: `rlp(transactionIndex)`. `transactionIndex` è il suo indice nel blocco estratto. Il trie delle ricevute non si aggiorna mai. Analogamente al trie delle transazioni, esistono ricevute correnti e legacy. Per interrogare una ricevuta specifica nel trie delle ricevute, servono l'indice della transazione nel suo blocco, il payload della ricevuta e il tipo di transazione. La ricevuta restituita può essere di tipo `Receipt`, definita come la concatenazione del `transaction type` e del `transaction payload`, oppure può essere di tipo `LegacyReceipt`, definito come `rlp([status, cumulativeGasUsed, logsBloom, logs])`. +Ogni blocco ha il proprio trie delle ricevute. Qui, un `path` è: `rlp(transactionIndex)`. `transactionIndex` è il suo indice nel blocco estratto. L'albero delle ricevute non è mai aggiornato. Analogamento all'albero delle Transazioni, esistono ricevute correnti e legacy. Per interrogare una ricevuta specifica nell'albero delle Ricevute, l'indice della transazione nel suo blocco, il carico utile di ricevute e il tipo di transazione sono necessari. La ricevuta Restituita può essere di tipo `Receipt`, definita come la concatenazione di `TransactionType` e `ReceiptPayload` o di tipo `LegacyReceipt`, definibile come `rlp([status, cumulativeGasUsed, logsBloom, logs])`. Maggiori informazioni a riguardo si possono trovare nella documentazione [EIP 2718](https://eips.ethereum.org/EIPS/eip-2718). ## Letture consigliate {#further-reading} -- [Trie di Patricia Merkle modificato - Come Ethereum salva uno stato](https://medium.com/codechain/modified-merkle-patricia-trie-how-ethereum-saves-a-state-e6d7555078dd) -- [Merkling su Ethereum](https://blog.ethereum.org/2015/11/15/merkling-in-ethereum/) -[Comprendere il trie di Ethereum](https://easythereentropy.wordpress.com/2014/06/04/understanding-the-ethereum-trie/) +- [Albero di Patricia Merkle Modificato - Come Ethereum risparmia uno stato](https://medium.com/codechain/modified-merkle-patricia-trie-how-ethereum-saves-a-state-e6d7555078dd) +- ["Merkling" su Ethereum](https://blog.ethereum.org/2015/11/15/merkling-in-ethereum/) +- [Comprendere l'albero di Ethereum](https://easythereentropy.wordpress.com/2014/06/04/understanding-the-ethereum-trie/) diff --git a/src/content/translations/it/developers/docs/data-structures-and-encoding/rlp/index.md b/src/content/translations/it/developers/docs/data-structures-and-encoding/rlp/index.md index c54595153eb..98a092eee96 100644 --- a/src/content/translations/it/developers/docs/data-structures-and-encoding/rlp/index.md +++ b/src/content/translations/it/developers/docs/data-structures-and-encoding/rlp/index.md @@ -43,27 +43,27 @@ In codice è: ```python def rlp_encode(input): if isinstance(input,str): - if len(input) == 1 and ord(input) < 0x80: return input - else: return encode_length(len(input), 0x80) + input - elif isinstance(input,list): + if len(input) == 1 and ord(input) < 0x80: + return input + return encode_length(len(input), 0x80) + input + elif isinstance(input, list): output = '' - for item in input: output += rlp_encode(item) + for item in input: + output += rlp_encode(item) return encode_length(len(output), 0xc0) + output -def encode_length(L,offset): +def encode_length(L, offset): if L < 56: return chr(L + offset) elif L < 256**8: BL = to_binary(L) return chr(len(BL) + offset + 55) + BL - else: - raise Exception("input troppo lungo") + raise Exception("input too long") def to_binary(x): if x == 0: return '' - else: - return to_binary(int(x / 256)) + chr(x % 256) + return to_binary(int(x / 256)) + chr(x % 256) ``` ## Esempi {#examples} @@ -137,8 +137,7 @@ def decode_length(input): lenOfListLen = prefix - 0xf7 listLen = to_integer(substr(input, 1, lenOfListLen)) return (1 + lenOfListLen, listLen, list) - else: - raise Exception("input don't conform RLP encoding form") + raise Exception("input does not conform to RLP encoding form") def to_integer(b): length = len(b) @@ -146,8 +145,7 @@ def to_integer(b): raise Exception("input is null") elif length == 1: return ord(b[0]) - else: - return ord(substr(b, -1)) + to_integer(substr(b, 0, -1)) * 256 + return ord(substr(b, -1)) + to_integer(substr(b, 0, -1)) * 256 ``` ## Letture consigliate {#further-reading} @@ -158,4 +156,4 @@ def to_integer(b): ## Argomenti correlati {#related-topics} -- [Trie di Patricia Merkle](/developers/docs/data-structures-and-encoding/patricia-merkle-tries) +- [Trie di Patricia Merkle](/developers/docs/data-structures-and-encoding/patricia-merkle-trie) diff --git a/src/content/translations/it/developers/docs/data-structures-and-encoding/ssz/index.md b/src/content/translations/it/developers/docs/data-structures-and-encoding/ssz/index.md index cecebc6efde..14b76b7d1a0 100644 --- a/src/content/translations/it/developers/docs/data-structures-and-encoding/ssz/index.md +++ b/src/content/translations/it/developers/docs/data-structures-and-encoding/ssz/index.md @@ -109,7 +109,7 @@ L’oggetto serializzato SSZ può essere poi merkle-zzato, ovvero trasformato in Ci sono anche casi in cui le foglie dell'albero non si distribuiscono naturalmente e uniformemente come nell'esempio di cui sopra. Ad esempio, la foglia 4 potrebbe essere un contenitore con diversi elementi che richiedono che sia aggiunta ulteriore "profondità" all'albero di Merkle, creando un albero non equilibrato. -Invece di far riferimento a questi elementi dell'albero come foglia X, nodo X, ecc., possiamo dare loro indici generalizzati che iniziano con radice = 1, contando da sinistra a destra per ogni livello. Questo è l'indice generalizzato spiegato sopra. Ogni elemento nell'elenco serializzato ha un indice generalizzato pari a `2**depth + idx`, dove idx è la sua posizione indicizzata a zero nell'oggetto serializzato e la profondità è il numero di livelli nell'albero di Merkle, determinabile come la radice quadrata del numero di elementi (foglie). +Invece di far riferimento a questi elementi dell'albero come foglia X, nodo X, ecc., possiamo dare loro indici generalizzati che iniziano con radice = 1, contando da sinistra a destra per ogni livello. Questo è l'indice generalizzato spiegato sopra. Ogni elemento nell'elenco serializzato ha un indice generalizzato pari a `2**depth + idx`, dove idx è la posizione indicizzata a zero nell'oggetto serializzato e "depth" è il numero di livelli nell'albero di Merkle, determinabile come il logaritmo a base due del numero di elementi (foglie). ## Indici generalizzati {#generalized-indices} diff --git a/src/content/translations/it/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md b/src/content/translations/it/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md new file mode 100644 index 00000000000..f3d88e86043 --- /dev/null +++ b/src/content/translations/it/developers/docs/data-structures-and-encoding/web3-secret-storage-definition/index.md @@ -0,0 +1,189 @@ +--- +title: Definizione di archiviazione segreta di Web3 +description: Definizione formale di archiviazione segreta di Web3 +lang: it +sidebarDepth: 2 +--- + +Per far funzionare la tua app su Ethereum, puoi utilizzare l'oggetto web3 fornito dalla libreria di web3.js. Fondamentalmente, comunica a un nodo locale tramite chiamate RPC. Il [web3](https://github.com/ethereum/web3.js/) funziona con qualsiasi nodo di Ethereum che esponga un livello RPC. + +Il `web3` contiene l'oggetto `eth`: web3.eth. + +```js +var fs = require("fs") +var recognizer = require("ethereum-keyfile-recognizer") + +fs.readFile("keyfile.json", (err, data) => { + var json = JSON.parse(data) + var result = recognizer(json) +}) + +/** result + * [ 'web3', 3 ] web3 (v3) keyfile + * [ 'ethersale', undefined ] Ethersale keyfile + * null invalid keyfile + */ +``` + +Questo documenta la **versione 3** della Definizione di Archiviazione Segreta del Web3. + +## Definizione {#definition} + +La codifica e decofica effettiva del file resta largamente immutata dalla versione 1, tranne nel fatto che l'algoritmo cripto non è più fisso ad AES-128-CBC (AES-128-CTR è ora il requisito minimo). Gran parte dei significati e dell'algoritmo sono simili alla versione 1, tranne `mac`, indicato come lo SHA3 (keccak-256) delle concatenazioni dei secondi 16 byte da sinistra della chiave derivata, insieme al `ciphertext` completo. + +I file della chiave segreta sono memorizzati direttamente in `~/.web3/keystore` (per i sistemi come Unix) e `~/AppData/Web3/keystore` (per Windows). Potrebbero esser denominati in qualsiasi modo, ma una buona convenzione è `.json`, dove `` è l'UUID da 128 bit dato alla chiave segreta (un proxy che preserva l'anonimato per l'indirizzo della chiave segreta). + +Tutti questi file sono associati a una password. Per derivare una certa chiave segreta del file `.json`, deriva prima la chiave di crittografia del file; ciò avviene prendendone la password e passandola per una funzione di derivazione della chiave, come descritto dalla chaive `kdf`. I parametri statici e dinamici dipendenti da KDF alla funzione KDF sono descritti nella chiave `kdfparams`. + +PBKDF2 dev'essere supportato da tutte le implementazioni minimamente conformi, denotato però: + +- `kdf`: `pbkdf2` + +Per PBKDF2, kdfparams include: + +- `prf`: deve essere `hmac-sha256` (potrebbe essere esteso in futuro); +- `c`: numero di iterazioni; +- `salt`: salt passati a PBKDF; +- `dklen`: lunghezza per la chiave derivata. Dev'essere >= 32. + +Una volta derivata la chiave del file, dovrebbe essere verificata tramite la derivazione del MAC. Il MAC dovrebbe essere calcolato come l'hash SHA3 (keccak-256) dell'insieme di byte formato come le concatenazioni dei secondi 16 byte da sinistra della chiave derivata, con i contenuti della chiave `ciphertext`, cioè: + +```js +KECCAK(DK[16..31] ++ ) +``` + +(dove `++` è l'operatore di concatenazione) + +Questo valore dovrebbe essere confrontato ai contenuti della chiave `mac`; se sono differenti, una password alternativa dovrebbe essere richiesta (o l'operazione dovrebbe essere annullata). + +Dopo la verifica della chiave del file, il testo di cifratura (la chiave `ciphertext` nel file) potrebbe essere decrittografato usando l'algoritmo crittografico simmetrico specificato dalla chiave `cipher` e parametrato tramite la chiave `cipherparams`. Se la dimensione della chiave derivata e la dimensione della chiave dell'algoritmo non corrispondono, lo zero è riempito, i byte a destra della chiave derivata dovrebbero essere utilizzati come la chiave per l'algoritmo. + +Tutte le implementazioni minimamente conformi devono supportare l'algoritmo AES-128-CTR, denotato tramite: + +- `cipher: aes-128-ctr` + +Questa cifratura prende i seguenti parametri, dati come chiavi alla chiave cipherparams: + +- `iv`: Vettore di inizializzazione a 128 bit per la cifratura. + +La chiave per la cifra è composta dai 16 bit a sinistra della chiave derivata, ossia, `DK[0..15]` + +La creazione/crittografia di una chiave segreta dovrebbe essere essenzialmente l'inverso di queste istruzioni. Assicurati che `uuid`, `salt` e `iv` siano effettivamente casuali. + +Oltre al campo `version`, che dovrebbe agire da identificatore "rigido" della versione, le implementazioni potrebbero anche utilizzare `minorversion` per tracciare le modifiche più piccole e non divisibili al formato. + +## Vettori di Prova {#test-vectors} + +Dettagli: + +- `Address`: `008aeeda4d805471df9b2a5b0f38a0c3bcba786b` +- `ICAP`: `XE542A5PZHH8PYIZUBEJEO0MFWRAPPIL67` +- `UUID`: `3198bc9c-6672-5ab3-d9954942343ae5b6` +- `Password`: `testpassword` +- `Secret`: `7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d` + +### PBKDF2-SHA-256 {#PBKDF2-SHA-256} + +Vettore di prova che utilizza `AES-128-CTR` e `PBKDF2-SHA-256`: + +Contenuti del file di `~/.web3/keystore/3198bc9c-6672-5ab3-d9954942343ae5b6.json`: + +```json +{ + "crypto": { + "cipher": "aes-128-ctr", + "cipherparams": { + "iv": "6087dab2f9fdbbfaddc31a909735c1e6" + }, + "ciphertext": "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46", + "kdf": "pbkdf2", + "kdfparams": { + "c": 262144, + "dklen": 32, + "prf": "hmac-sha256", + "salt": "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd" + }, + "mac": "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2" + }, + "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6", + "version": 3 +} +``` + +**Intermedi**: + +`Derived key`: `f06d69cdc7da0faffb1008270bca38f5e31891a3a773950e6d0fea48a7188551` `MAC Body`: `e31891a3a773950e6d0fea48a71885515318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46` `MAC`: `517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2` `Cipher key`: `f06d69cdc7da0faffb1008270bca38f5` + +### Scrypt {#scrypt} + +Vettore di prova che utilizza AES-128-CTR e Scrypt: + +```json +{ + "crypto": { + "cipher": "aes-128-ctr", + "cipherparams": { + "iv": "83dbcc02d8ccb40e466191a123791e0e" + }, + "ciphertext": "d172bf743a674da9cdad04534d56926ef8358534d458fffccd4e6ad2fbde479c", + "kdf": "scrypt", + "kdfparams": { + "dklen": 32, + "n": 262144, + "p": 8, + "r": 1, + "salt": "ab0c7876052600dd703518d6fc3fe8984592145b591fc8fb5c6d43190334ba19" + }, + "mac": "2103ac29920d71da29f15d75b4a16dbe95cfd7ff8faea1056c33131d846e3097" + }, + "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6", + "version": 3 +} +``` + +**Intermedi**: + +`Derived key`: `fac192ceb5fd772906bea3e118a69e8bbb5cc24229e20d8766fd298291bba6bd` `MAC Body`: `bb5cc24229e20d8766fd298291bba6bdd172bf743a674da9cdad04534d56926ef8358534d458fffccd4e6ad2fbde479c` `MAC`: `2103ac29920d71da29f15d75b4a16dbe95cfd7ff8faea1056c33131d846e3097` `Cipher key`: `fac192ceb5fd772906bea3e118a69e8b` + +## Alterazioni dalla Versione 1 {#alterations-from-v2} + +Questa versione corregge diverse incongruenze con la versione 1 pubblicata [qui](https://github.com/ethereum/homestead-guide/blob/master/old-docs-for-reference/go-ethereum-wiki.rst/Passphrase-protected-key-store-spec.rst). In breve sono: + +- Capitalizzazione ingiustificata e incoerente (scrypt minuscolo, maiuscole miste in Kdf e MAC maiuscolo). +- Indirizzo non necessario e compromette l'anonimato. +- `Salt` è intrinsecamente un parametro della funzione di derivazione della chiave e deve essere associato a esso, non con le cripto in generale. +- _SaltLen_ non necessario (basta derivarlo da Salt). +- La funzione di derivazione della chiave è data, ma l'algoritmo cripto è specificato rigidamente. +- `Version` è intrinsecamente numerica, ma è comunque una stringa (il versionamento strutturato sarebbe possibile con una stringa, ma è considerabile fuori ambito per un formato di file di configurazione che cambia raramnte). +- `KDF` e `cipher` sono concetti notoriamente fratelli, seppur organizzati diversamente. +- `MAC` è calcolato tramite un pezzo di dati indipendente dalla spaziatura(!) + +Le modifiche sono state apportate al formato per restituire il seguente file, funzionalmente equivalente all'esempio dato sulla pagina collegata in precedenza: + +```json +{ + "crypto": { + "cipher": "aes-128-cbc", + "ciphertext": "07533e172414bfa50e99dba4a0ce603f654ebfa1ff46277c3e0c577fdc87f6bb4e4fe16c5a94ce6ce14cfa069821ef9b", + "cipherparams": { + "iv": "16d67ba0ce5a339ff2f07951253e6ba8" + }, + "kdf": "scrypt", + "kdfparams": { + "dklen": 32, + "n": 262144, + "p": 1, + "r": 8, + "salt": "06870e5e6a24e183a5c807bd1c43afd86d573f7db303ff4853d135cd0fd3fe91" + }, + "mac": "8ccded24da2e99a11d48cda146f9cc8213eb423e2ea0d8427f41c3be414424dd", + "version": 1 + }, + "id": "0498f19a-59db-4d54-ac95-33901b4f1870", + "version": 2 +} +``` + +## Modifiche dalla Versione 2 {#alterations-from-v2} + +La versione 2 era un'implementazione iniziale in C++ con numerosi bug. Tutti gli elementi essenziali restano immutati da essa. diff --git a/src/content/translations/it/developers/docs/ethereum-stack/index.md b/src/content/translations/it/developers/docs/ethereum-stack/index.md index f3764783fc6..e1296df03d0 100644 --- a/src/content/translations/it/developers/docs/ethereum-stack/index.md +++ b/src/content/translations/it/developers/docs/ethereum-stack/index.md @@ -10,11 +10,11 @@ Sono comunque disponibili tecnologie base di Ethereum che aiutano a fornire un m ## Livello 1: macchina virtuale Ethereum {#ethereum-virtual-machine} -La [Macchina Virtuale di Ethereum (EVM)](/developers/docs/evm/) è l'ambiente d'esecuzione per i contratti intelligenti su Ethereum. Tutti i contratti intelligenti e i cambiamenti di stato sulle blockchain di Ethereum sono eseguiti dalle [transazioni](/developers/docs/transactions/). La EVM gestisce l'elaborazione di tutte le transazioni sulla rete Ethereum. +La [Macchina Virtuale di Ethereum (EVM)](/developers/docs/evm/) è l'ambiente di esecuzione per i contratti intelligenti su Ethereum. Tutti i contratti intelligenti e i cambiamenti di stato sulle blockchain di Ethereum sono eseguiti dalle [transazioni](/developers/docs/transactions/). La EVM gestisce l'elaborazione di tutte le transazioni sulla rete Ethereum. Come avviene con ogni macchina virtuale, la EVM crea un livello di astrazione fra il codice in esecuzione e la macchina che esegue tale codice (il nodo Ethereum). Al momento la EVM è in esecuzione su migliaia di nodi distribuiti in tutto il mondo. -La EVM utilizza un insieme di istruzioni opcode per eseguire attività specifiche. Questi 140 opcode univoci permettono alla EVM di essere Turing completa, cioè di essere in grado di elaborare praticamente tutto, se sono presenti risorse sufficienti. +La EVM utilizza un insieme di istruzioni opcode per eseguire attività specifiche. Questi (140) opcode (univoci) consentono all'EVM di essere [Turing-completa](https://en.wikipedia.org/wiki/Turing_completeness), cioè in grado di calcolare praticamente tutto, se sono presenti risorse sufficienti. A uno sviluppatore di dapp non serve conoscere a fondo la EVM, gli basta sapere che esiste e fa funzionare in modo affidabile tutte le applicazioni su Ethereum senza interruzioni. diff --git a/src/content/translations/it/developers/docs/frameworks/index.md b/src/content/translations/it/developers/docs/frameworks/index.md index dfaf4fd95db..80d45efefe4 100644 --- a/src/content/translations/it/developers/docs/frameworks/index.md +++ b/src/content/translations/it/developers/docs/frameworks/index.md @@ -46,32 +46,37 @@ Prima di iniziare a studiare i framework, raccomandiamo la lettura della nostra - [Home page](https://www.web3labs.com/web3j-sdk) - [Documentazione](https://docs.web3j.io) -- [GitHub](https://github.com/web3j/web3j) +- [Github](https://github.com/web3j/web3j) -**OpenZeppelin SDK:** **_Gli Strumenti Definitivi per i Contratti Intelligenti: Una suite di strumenti per aiutarti a sviluppare, compilare, aggiornare, distribuire e interagire con i contratti intelligenti_** +**OpenZeppelin SDK:** **_Il kit di strumenti definitivo per i contratti intelligenti: una suite di strumenti per aiutarti a sviluppare, compilare, aggiornare, distribuire e interagire con i contratti intelligenti_** - [SDK OpenZeppelin](https://openzeppelin.com/sdk/) -- [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk) +- [Github](https://github.com/OpenZeppelin/openzeppelin-sdk) - [Forum della community](https://forum.openzeppelin.com/c/support/17) -**Create Eth App:** **_crea app per Ethereum con un comando. Offre una vasta scelta di framework per l'interfaccia utente e modelli DeFI tra cui scegliere._** +**Create Eth App -** **_Crea app per Ethereum con un comando. Offre una vasta scelta di framework per l'interfaccia utente e modelli DeFI tra cui scegliere._** -- [GitHub](https://github.com/paulrberg/create-eth-app) -- [Template](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates) +- [Github](https://github.com/paulrberg/create-eth-app) +- [Modelli](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates) -**Scaffold-Eth:** **_I componenti Ethers.js + Hardhat + React e gli hook per web3: tutto ciò che ti serve per iniziare a creare applicazioni decentralizzate alimentate dai contratti intelligenti._** +**Scaffold-Eth -** **_I componenti Ethers.js + Hardhat + React e gli hook per web3: tutto ciò che ti serve per iniziare a creare applicazioni decentralizzate alimentate da contratti intelligenti._** - [GitHub](https://github.com/austintgriffith/scaffold-eth) +**Tenderly -** **_Piattaforma di sviluppo di Web3 che consente agli sviluppatori della blockchain di costruire, testare, eseguire il debug, monitorare e gestire i contratti intelligenti, nonché di migliorare l'UX della dapp._** + +- [Sito Web](https://tenderly.co/) +- [Documentazione](https://docs.tenderly.co/ethereum-development-practices) + **The Graph:** **_ The Graph per interrogare efficientemente i dati della blockchain_** - [Sito Web](https://thegraph.com/) -- [Guida](/developers/tutorials/the-graph-fixing-web3-data-querying/) +- [Tutorial](/developers/tutorials/the-graph-fixing-web3-data-querying/) -**Alchemy:** **_ piattaforma di sviluppo di Ethereum._** +**Alchemy -** **_Piattaforma di sviluppo Ethereum_** - [alchemy.com](https://www.alchemy.com/) -- [GitHub](https://github.com/alchemyplatform) +- [Github](https://github.com/alchemyplatform) - [Discord](https://discord.com/invite/A39JVCM) **Foundry -** **_Un toolkit velocissimo, portatile e modulare per lo sviluppo di applicazioni di Ethereum scritte in Rust._** @@ -80,10 +85,16 @@ Prima di iniziare a studiare i framework, raccomandiamo la lettura della nostra - [GitHub](https://github.com/gakonst/foundry/) - [Strumenti per Foundry](https://github.com/crisgarner/awesome-foundry) +**NodeReal**: **_Piattaforma di sviluppo per Ethereum._** + +- [Nodereal.io](https://nodereal.io/) +- [GitHub](https://github.com/node-real) +- [Discord](https://discord.gg/V5k5gsuE) + ## Letture consigliate {#further-reading} _Conosci una risorsa pubblica che ti è stata utile? Modifica questa pagina e aggiungila!_ ## Argomenti correlati {#related-topics} -- [Configura un ambiente di sviluppo locale](/developers/local-environment/) +- [Imposta un ambiente di sviluppo locale](/developers/local-environment/) diff --git a/src/content/translations/it/developers/docs/ides/index.md b/src/content/translations/it/developers/docs/ides/index.md index 8cbb2f14681..b849a2606b3 100644 --- a/src/content/translations/it/developers/docs/ides/index.md +++ b/src/content/translations/it/developers/docs/ides/index.md @@ -12,9 +12,17 @@ Se desideri provare a scrivere del codice prima di [configurare un ambiente di s **[Remix](https://remix.ethereum.org/)**: **_IDE basato sul web che integra analisi statica e una macchina virtuale per una blockchain di prova_** +- [Documentazione](https://remix-ide.readthedocs.io/en/latest/#) +- [Gitter](https://gitter.im/ethereum/remix) + **[ChainIDE](https://chainide.com/)**: **_un IDE multi-catena basato su cloud_** -**[Replit (Solidity Starter)](https://replit.com/@replit/Solidity-starter-beta)**: **_un ambiente di sviluppo personalizzabile per Ethereum con reloading immediato, controllo degli errori e supporto della rete di prova di prim'ordine_** +- [Documentazione](https://chainide.gitbook.io/chainide-english-1/) +- [Forum di supporto](https://forum.chainide.com/) + +**[Replit (Solidity Starter - Beta) ](https://replit.com/@replit/Solidity-starter-beta)** - **_Un ambiente di sviluppo personalizzabile per Ethereum con ricarica rapida, controllo degli errori e supporto della rete di prova di prima classe_** + +- [Docs](https://docs.replit.com/) **[Tenderly Sandbox](https://sandbox.tenderly.co/)**: **_un ambiente di prototipazione veloce è possibile scrivere, eseguire ed effettuare il debug dei contratti intelligenti nel browser usando Solidity e JavaScript_** @@ -37,7 +45,7 @@ Gli IDE più diffusi hanno plugin integrati che migliorano l'esperienza di svilu - [Atom](https://atom.io/) - [GitHub](https://github.com/atom) -- [Pacchetti Ethereum](https://atom.io/packages/search?utf8=%E2%9C%93&q=keyword%3Aethereum&commit=Search) +- [Ethereum packages](https://atom.io/packages/search?utf8=%E2%9C%93&q=keyword%3Aethereum&commit=Search) **JetBrains IDEs (IntelliJ IDEA, ecc.) -** **_Strumenti essenziali per sviluppatori di software e team_** @@ -52,7 +60,8 @@ Gli IDE più diffusi hanno plugin integrati che migliorano l'esperienza di svilu ## Plugin ed estensioni {#plugins-extensions} -- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - Linguaggio Solidity di Ethereum per Visual Studio Code +- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - Ethereum Solidity Language per Visual Studio Code +- [Solidity + Hardhat per VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - Supporto Solidity e Hardhat fornito da Hardhat team - [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - Formattatore di codice basato su Prettier ## Letture consigliate {#further-reading} diff --git a/src/content/translations/it/developers/docs/networking-layer/cons_client_net_layer.png b/src/content/translations/it/developers/docs/networking-layer/cons_client_net_layer.png new file mode 100644 index 00000000000..825d2c579c0 Binary files /dev/null and b/src/content/translations/it/developers/docs/networking-layer/cons_client_net_layer.png differ diff --git a/src/content/translations/it/developers/docs/networking-layer/index.md b/src/content/translations/it/developers/docs/networking-layer/index.md index 35b1eab2685..51054ee0e54 100644 --- a/src/content/translations/it/developers/docs/networking-layer/index.md +++ b/src/content/translations/it/developers/docs/networking-layer/index.md @@ -13,7 +13,7 @@ I client d'esecuzione compiono gossip sulle transazioni sulla rete tra pari del ## Prerequisiti {#prerequisites} -Per comprendere questa pagina è utile avere alcune nozioni di [nodi e client](/src/content/developers/docs/nodes-and-clients/) di Ethereum. +Per comprendere questa pagina è utile avere alcune nozioni di [nodi e client](/developers/docs/nodes-and-clients/) di Ethereum. ## Il livello d'esecuzione {#execution-layer} @@ -41,6 +41,8 @@ Una volta che il nodo riceve un elenco di vicini dal nodo d'avvio, inizia con og start client --> connect to bootnode --> bond to bootnode --> find neighbours --> bond to neighbours ``` +I client di esecuzione stanno attualmente utilizzando il protocollo di ricerca [Discv4](https://github.com/ethereum/devp2p/blob/master/discv4.md) e c'è uno sforzo attivo per migrare al protocollo [Discv5](https://github.com/ethereum/devp2p/tree/master/discv5). + #### ENR: Ethereum Node Records {#enr} L’[Ethereum Node Records (ENR)](/developers/docs/networking-layer/network-addresses/) è un oggetto contenente tre elementi fondamentali: una firma (hash dei contenuti del registro creato secondo qualche schema d'identità acconsentito), una sequenza numerica che monitora le modifiche al registro e un elenco arbitrario di coppie chiave-valore. Questo è un formato a prova di futuro che consente uno scambio più facile di informazioni identificative tra nuovi peer ed è preferibile rispetto al formato dell'[indirizzo di rete](/developers/docs/networking-layer/network-addresses) per i nodi di Ethereum. @@ -53,7 +55,7 @@ UDP non supporta le funzioni di controllo degli errori, reinvio di pacchetti non DevP2P è esso stesso un intero stack di protocolli che Ethereum implementa per stabilire e mantenere la rete tra peer-to-peer. Dopo che i nuovi nodi accedono alla rete, le loro interazioni sono governate dai protocolli nello stack [DevP2P](https://github.com/ethereum/devp2p). Questi si basano tutti su TCP e includono il protocollo di trasporto RLPx, il protocollo via cavo e diversi protocolli secondari. [RLPx](https://github.com/ethereum/devp2p/blob/master/rlpx.md) è il protocollo che governa iniziazione, autenticazione e manutenzione delle sessioni tra nodi. RLPx codifica i messaggi usando il RLP (Recursive Length Prefix), un metodo molto efficiente in termini di spazio che codifica i dati in una struttura minimale per l'invio tra nodi. -Una sessione di RLPx tra due nodi inizia con un "handshaking" crittografico iniziale, in cui il nodo invia un messaggio d'autenticazione, poi verificato dal peer. Se la verifica va a buon fine, il peer genera un messaggio di riconoscimento dell'autenticazione da restituire al nodo iniziatore. Si tratta di un processo di scambio di chiavi che consente ai nodi di comunicare privatamente e in sicurezza. Un "handshaking" crittografico andato a buon fine attiva poi entrambi i nodi spingendoli a inviare un messaggio di "saluto" (hello) all'altro "via cavo". Il protocollo via cavo è avviato da uno scambio di messaggi di saluto andato a buon fine. +Una sessione di RLPx tra due nodi inizia con un "handshaking" crittografico iniziale, in cui il nodo invia un messaggio d'autenticazione, poi verificato dal peer. Se la verifica va a buon fine, il peer genera un messaggio di riconoscimento dell'autenticazione da restituire al nodo iniziatore. Si tratta di un processo di scambio di chiavi che consente ai nodi di comunicare privatamente e in sicurezza. Un "handshaking" crittografico andato a buon fine attiva poi entrambi i nodi spingendoli a inviare un messaggio "hello" all'altro "on the wire". Il protocollo via cavo è avviato da uno scambio di messaggi di saluto andato a buon fine. Il messaggio di saluto contiene: @@ -79,7 +81,7 @@ Si tratta di un protocollo minimale per sincronizzare i client leggeri. Tradizio #### Snap {#snap} -Il [protocollo snap](https://github.com/ethereum/devp2p/blob/master/caps/snap.md#ethereum-snapshot-protocol-snap) è un'estensione facoltativa che consente ai peer di scambiare istantanee degli stati recenti, consentendo ai peer di verificare i dati del conto e d'archiviazione senza dover scaricare i nodi dell'albero di Merkle intermedi. +Il [protocollo snap](https://github.com/ethereum/devp2p/blob/master/caps/snap.md#ethereum-snapshot-protocol-snap) è un'estensione ottica che consente ai pari di scambiare istantanee degli stati recenti, consentendo ai pari di verificare i dati del conto e dell'archiviazione senza dover scaricare nodi intermedi dell'albero di Merkle. #### Wit (witness protocol) {#wit} @@ -144,9 +146,7 @@ Un sommario del flusso di controllo è mostrato di seguito, con indicazione tra Una volta che il blocco è stato attestato da sufficienti validatori, è aggiunto alla testa della catena, giustificato e, infine, finalizzato. -![](cons_client_net_layer.png) - -![](exe_client_net_layer.png) +![](cons_client_net_layer.png) ![](exe_client_net_layer.png) Schematica del livello di rete per i client del consenso e d'esecuzione, da [ethresear.ch](https://ethresear.ch/t/eth1-eth2-client-relationship/7248) diff --git a/src/content/translations/it/developers/docs/networking-layer/network-addresses/index.md b/src/content/translations/it/developers/docs/networking-layer/network-addresses/index.md index dcea64414f3..f681c1c7f35 100644 --- a/src/content/translations/it/developers/docs/networking-layer/network-addresses/index.md +++ b/src/content/translations/it/developers/docs/networking-layer/network-addresses/index.md @@ -35,6 +35,4 @@ Ethereum Node Records (ENR) è un formato standardizzato per gli indirizzi di re ## Letture consigliate {#further-reading} -- [EIP-778: Ethereum Node Records (ENR)](https://eips.ethereum.org/EIPS/eip-778) -- [Indirizzi di rete su Ethereum](https://dean.eigenmann.me/blog/2020/01/21/network-addresses-in-ethereum/) -- [LibP2P: Multiaddr-Enode-ENR?!](https://consensys.net/diligence/blog/2020/09/libp2p-multiaddr-enode-enr/) +[EIP-778: Ethereum Node Records (ENR)](https://eips.ethereum.org/EIPS/eip-778) [Indirizzi di rete su Ethereum](https://dean.eigenmann.me/blog/2020/01/21/network-addresses-in-ethereum/) [LibP2P: Multiaddr-Enode-ENR?!](https://consensys.net/diligence/blog/2020/09/libp2p-multiaddr-enode-enr/) diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/archive-nodes/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/archive-nodes/index.md new file mode 100644 index 00000000000..28a53014851 --- /dev/null +++ b/src/content/translations/it/developers/docs/nodes-and-clients/archive-nodes/index.md @@ -0,0 +1,80 @@ +--- +title: Nodo archivio di Ethereum +description: Una panoramica dei nodi archivio +lang: it +sidebarDepth: 2 +--- + +Un nodo archivio è un'istanza di un client di Ethereum configurata per creare un archivio di tutti gli stati storici. È uno strumento utile per certi casi d'uso ma potrebbe essere più complicato da eseguire di un nodo completo. + +## Prerequisiti {#prerequisites} + +Dovresti comprendere il concetto di [nodo di Ethereum](/developers/docs/nodes-and-clients/), [la sua architettura](/developers/docs/nodes-and-clients/node-architecture/), le [strategie di sincronizzazione](https://ethereum.org/en/developers/docs/nodes-and-clients/#sync-modes) e le pratiche della sua [esecuzione](/developers/docs/nodes-and-clients/run-a-node/) e [utilizzo](/developers/docs/apis/json-rpc/). + +## Cos'è un nodo archivio + +Per cogliere l'importanza di un nodo archivio, chiariamo il concetto di "stato". Ethereum è definibile come una _macchina di stato basata sulle transazioni_. Consiste in conti e applicazioni che eseguono transazioni, i cui stati cambiano. I dati globali con informazioni su ogni conto e contratto sono memorizzati in un database ad albero, detto stato. Questo è gestito dal client del livello di esecuzione (EL) e include: + +- Saldi e nonce dei conti +- Codice del contratto e archiviazione +- Dati correlati al consenso, es. il Contratto di deposito di staking + +Per interagire con la rete, verificare e produrre nuovi blocchi, i client di Ethereum devono tenere il passo con i cambiamenti più recenti (la punta della catena) e, dunque, con lo stato corrente. Un client del livello di esecuzione configurato come un nodo completo verifica e segue l'ultimo stato della rete, memorizzando nella cache solo gli ultimi stati, ad esempio quello associato agli ultimi 128 blocchi, così che possa gestire le riorganizzazioni della catena e fornire accesso rapido ai dati recenti. Lo stato recente è ciò che tutti i client necessitano per verificare le transazioni in entrata e per utilizzare la rete. + +Puoi immaginare lo stato come un'istantanea momentanea della rete a un dato blocco e l'archivio come una riproduzione dello storico. + +Gli stati storici possono essere rimossi in sicurezza, poiché non sono necessari per l'operatività della rete e sarebbe inutilmente ridondante per il client mantenere tutti i dati obsoleti. Gli stati esistenti prima di qualche blocco recente (es. i 128 blocchi prima della testa) sono di fatto gettati via. I nodi completi mantengono soltanto i dati storici della blockchain (blocchi e transazioni) e istantanee storiche occasionali utilizzabili per rigenerare i vecchi stati su richiesta. Lo fanno eseguendo nuovamente le vecchie transazioni nell'EVM, il che può essere impegnativo a livello computazionale quando lo stato desiderato è distante dall'istantanea più vicina. + +Tuttavia, ciò significa che accedere a uno stato storico su un nodo completo produce numerosi calcoli. Il client potrebbe dover eseguire tutte le transazioni precedenti e calcolare uno stato storico dalla genesi. I nodi archivio risolvono tale problema, memorizzando non solo gli stati più recenti ma ogni stato storico creato dopo ogni blocco. Fondamentalmente raggiungono un compromesso con maggiori requisiti di spazio su disco. + +È importante notare che la rete non dipende dal fatto che i nodi archivio mantengano e forniscano tutti i dati storici. Come detto sopra, tutti gli stati intermedi storici sono derivabili su un nodo completo. Le transazioni sono memorizzate da qualsiasi nodo completo (attualmente meno di 400G) e riproducibili per costruire l'intero archivio. + +### Casi d'uso + +L'utilizzo regolare di Ethereum, come inviare transazioni, distribuire contratti, verificare il consenso, ecc., non richiede l'accesso agli stati storici. Gli utenti non necessitano mai di un nodo archivio per un'interazione standard con la rete. + +Il principale vantaggio dell'archivio di stato è un accesso rapido alle richieste sugli stati storici. Ad esempio, il nodo archivio restituirà prontamente risultati come: + +- _Qual era il saldo di ETH del conto 0x1337... al blocco 15537393?_ +- _Qual era il saldo del token 0x nel contratto 0x al blocco 1920000?_ + +Come spiegato sopra, un nodo completo dovrebbe generare questi dati dall'esecuzione dell'EVM, utilizzando CPU e richiedendo tempo. I nodi archivio vi accedono sul disco e servono immediatamente le risposte. Questa è un'utile funzionalità per certe parti dell'infrastruttura, ad esempio: + +- Fornitori di servizi come i block explorer +- Ricercatori +- Analisti della sicurezza +- Sviluppatori di Dapp +- Controllo e conformità + +Esistono anche vari [servizi](/developers/docs/nodes-and-clients/nodes-as-a-service/) gratuiti che consentono l'accesso a dati storici. Essendo più impegnativo eseguire un nodo archivio, questo accesso è per lo più limitato e funziona soltanto per l'accesso occasionale. Se il tuo progetto richiede l'accesso costante ai dati storici, dovresti considerare di eseguirne uno tu stesso. + +## Implementazioni e utilizzi + +Il nodo archivio, in questo contesto, indica i dati serviti dai client del livello di esecuzione rivolti agli utenti mentre gestiscono il database di stato e forniscono gli endpoint JSON-RPC. Opzioni di configurazione, tempi di sincronizzazione e dimensioni del database potrebbero variare a seconda del client. Per i dettagli, sei pregato di fare riferimento alla documentazione fornita dal tuo client. + +Prima di avviare il tuo nodo archivio, scopri le differenze tra i client e, in particolare, i vari [requisiti hardware](/developers/docs/nodes-and-clients/run-a-node/#requirements). Gran parte dei client non è ottimizzata per questa funzionalità e i loro archivi richiedono oltre 12TB di spazio. Per contro, le implementazioni come Erigon possono memorizzare gli stessi dati in meno di 3TB, il che li rende il metodo più efficace per eseguire un nodo archivio. + +## Pratiche consigliate + +Oltre ai [consigli generali per eseguire un nodo](/developers/docs/nodes-and-clients/run-a-node/), un nodo archivio potrebbe avere requisiti maggiori in termini di hardware e manutenzione. Considerando le [funzionalità chiave](https://github.com/ledgerwatch/erigon#key-features) di Erigon, l'approccio più pratico è utilizzare l'implementazione del client di [Erigon](https://ethereum.org/en/developers/docs/nodes-and-clients/#erigon). + +### Hardware + +Assicurati sempre di verificare i requisiti hardware per una data modalità nella documentazione di un client. Il principale requisito per i nodi archivio è lo spazio su disco. A seconda del client, varia da 3TB a 12TB. Anche se gli HDD potrebbero essere considerati la migliore soluzione per grandi quantità di dati, sincronizzare e aggiornare costantemente la testa della catena richiederà dischi SSD. I dischi [SATA](https://www.cleverfiles.com/help/sata-hard-drive.html) sono abbastanza buoni ma dovrebbero essere di una qualità affidabile, almeno [TLC](https://blog.synology.com/tlc-vs-qlc-ssds-what-are-the-differences). I dischi possono esser montati in un computer fisso o un server dotato di un numero sufficiente di slot. Tali dispositivi dedicati sono ideali per eseguire nodi con tempi di disponibilità elevati. È assolutamente possibile eseguirli su un laptop, ma la portabilità comporterà un costo aggiuntivo. + +Tutti i dati devono entrare in un volume, dunque i dischi devono essere uniti, ad esempio con [RAID0](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_0) o [LVM](https://web.mit.edu/rhel-doc/5/RHEL-5-manual/Deployment_Guide-en-US/ch-lvm.html). Inoltre, potrebbe valere la pena di considerare l'utilizzo di [ZFS](https://en.wikipedia.org/wiki/ZFS) poiché supporta la "Copy-on-write", che assicura che i dati siano scritti correttamente senza alcun errore di basso livello. + +Per una maggiore stabilità e sicurezza nel prevenire la corruzione accidentale del database, specialmente in una configurazione professionale, prendi in considerazione di utilizzare la [memoria ECC](https://en.wikipedia.org/wiki/ECC_memory), se il tuo sistema la supporta. Generalmente si consiglia che le dimensioni della RAM siano le stesse richieste per un nodo completo, ma maggiori quantità di RAM possono aiutare a velocizzare la sincronizzazione. + +Durante la sincronizzazione iniziale, i client in modalità archivio eseguiranno ogni transazione dalla genesi. La velocità di esecuzione è per lo più limitata dalla CPU, quindi una CPU più veloce può aiutare con i tempi della sincronizzazione iniziale. Sul computer del consumatore medio, la sincronizzazione iniziale può richiedere fino a un mese. + +## Letture consigliate {#further-reading} + +- [Nodo completo vs nodo archivio di Ethereum](https://www.quicknode.com/guides/infrastructure/ethereum-full-node-vs-archive-node) - _QuickNode, settembre 2022_ +- [Costruire il proprio nodo archivio di Ethereum](https://tjayrush.medium.com/building-your-own-ethereum-archive-node-72c014affc09) - _Thomas Jay Rush, agosto 2021_ +- [Come configurare Erigon, RPC di Erigon e TrueBlocks (scrape e API) come servizi](https://magnushansson.xyz/blog_posts/crypto_defi/2022-01-10-Erigon-Trueblocks) _– Magnus Hansson, aggiornato a settembre 2022_ + +## Argomenti correlati {#related-topics} + +- [ Nodi e client](/developers/docs/nodes-and-clients/) +- [Eseguire un nodo](/developers/docs/nodes-and-clients/run-a-node/) diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/bootnodes/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/bootnodes/index.md new file mode 100644 index 00000000000..151ea0ce135 --- /dev/null +++ b/src/content/translations/it/developers/docs/nodes-and-clients/bootnodes/index.md @@ -0,0 +1,31 @@ +--- +title: Introduzione ai nodi d'avvio di Ethereum +description: Le informazioni di base necessarie per comprendere i nodi d'avvio +lang: it +--- + +Quando un nuovo nodo si unisce alla rete di Ethereum, deve connettersi ai nodi già sulla rete per poter poi scoprire nuovi pari. Questi punti d'accesso alla rete di Ethereum sono detti nodi d'avvio. I client ne contengono solitamente un elenco a codifica fissa. Questi nodi d'avvio sono tipicamente eseguiti dal team delle operazioni di sviluppo della Ethereum Foundation o dai team degli stessi client. Nota che i nodi d'avvio non equivalgono ai nodi statici. I nodi statici sono chiamati ripetutamente, mentre i nodi d'avvio sono chiamati soltanto se non esistono abbastanza pari a cui connettersi e se un nodo necessita di avviare qualche nuova connessione. + +## Connettersi a un nodo d'avvio {#connect-to-a-bootnode} + +Gran parte dei client contiene un elenco integrato di nodi d'avvio, ma potresti voler anche eseguire il tuo o utilizzarne uno che non appartenga all'elenco a codifica fissa del client. In questo caso, puoi specificarli all'avvio del tuo client come segue (l'esempio è per Geth, consulta la documentazione del tuo client): + +``` +geth --bootnodes "enode://@:" +``` + +## Eseguire un nodo d'avvio {#run-a-bootnode} + +I nodi d'avvio sono nodi completi non posti dietro una NAT ([Traduzione dell'indirizzo di rete](https://www.geeksforgeeks.org/network-address-translation-nat/)). Ogni nodo completo può agire da nodo d'avvio a condizione che sia pubblicamente disponibile. + +Quando avvii un nodo, dovrebbe registrare il tuo [enode](/developers/docs/networking-layer/network-addresses/#enode), un identificativo pubblico utilizzabile dagli altri per connettersi al tuo nodo. + +L'enode è solitamente rigenerato a ogni riavvio, quindi assicurati di consultare la documentazione del tuo client su come generare un enode persistente per il tuo nodo d'avvio. + +Per poter essere un buon nodo d'avvio è una buona idea incrementare il numero massimo di pari che possono connettersi a esso. Eseguire un nodo d'avvio con molti pari aumenterà significativamente i requisiti della larghezza di banda. + +## Nodi d'avvio disponibili {#available-bootnodes} + +Un elenco di nodi d'avvio integrati in go-ethereum si può trovare [qui](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23). Questi nodi d'avvio sono mantenuti dalla Ethereum Foundation e dal team di go-ethereum. + +Sono disponibili altri elenchi di nodi d'avvio tenuti da volontari. Assicurati di includere sempre almeno un nodo d'avvio ufficiale, altrimenti potresti subire un attacco eclipse. diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/client-diversity/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/client-diversity/index.md index ec8d3a68399..5510803080c 100644 --- a/src/content/translations/it/developers/docs/nodes-and-clients/client-diversity/index.md +++ b/src/content/translations/it/developers/docs/nodes-and-clients/client-diversity/index.md @@ -75,7 +75,9 @@ Per "indirizzare" la diversità dei client non basta che i singoli utenti scelga [Teku](https://consensys.net/knowledge-base/ethereum-2/teku/) -[Lodestar](https://github.com/ChainSafe/lodestar) - _In fase di revisione e controllo_ +[Lodestar](https://github.com/ChainSafe/lodestar) + +[Prysm](https://docs.prylabs.network/docs/getting-started) Gli utenti tecnici possono aiutare ad accelerare questo processo scrivendo più tutorial e documentazioni per i client di minoranza e incoraggiando i propri peer che eseguono dei nodi a migrare dai client dominanti. Le guide per passare a un client di consenso di minoranza sono disponibili su [clientdiversity.org](https://clientdiversity.org/). @@ -86,9 +88,7 @@ Diversi pannelli di controllo forniscono statistiche sulla diversità dei client **Livello di consenso:** - [Rated.network](https://www.rated.network/) -- [clientdiversity.org](https://clientdiversity.org/) - -**Livello di esecuzione:** +- [clientdiversity.org](https://clientdiversity.org/) **Livello di esecuzione:** - [execution-diversity.info](https://execution-diversity.info/) - [Ethernodes](https://ethernodes.org/) diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/eth1eth2client.png b/src/content/translations/it/developers/docs/nodes-and-clients/eth1eth2client.png new file mode 100644 index 00000000000..047b9d3e567 Binary files /dev/null and b/src/content/translations/it/developers/docs/nodes-and-clients/eth1eth2client.png differ diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/index.md index 7a255e4b04e..7a7c1cdb097 100644 --- a/src/content/translations/it/developers/docs/nodes-and-clients/index.md +++ b/src/content/translations/it/developers/docs/nodes-and-clients/index.md @@ -69,28 +69,28 @@ Se desideri [eseguire il tuo nodo](/developers/docs/nodes-and-clients/run-a-node ### Nodo leggero {#light-node} -Invece di scaricare ogni blocco, i nodi leggeri scaricano le intestazioni dei blocchi. Queste contengono solo le informazioni sommarie sui contenuti dei blocchi. Ogni altra informazione richiesta dal nodo leggero viene richiesta dal nodo completo. Il nodo leggero può quindi verificare in modo indipendente i dati che riceve rispetto alle radici di stato nelle intestazioni dei blocchi. I nodi leggeri consentono agli utenti di partecipare alla rete Ethereum senza l'hardware potente o l'elevata larghezza di banda necessari per eseguire i nodi completi. Infine, i nodi leggeri potrebbero funzionare su telefoni cellulari o dispositivi embedded. I nodi leggeri non partecipano al consenso (ossia non possono essere miner/validatori), ma possono accedere alla blockchain di Ethereum con la stessa funzionalità di un nodo completo. +Invece di scaricare ogni blocco, i nodi leggeri scaricano le intestazioni dei blocchi. Queste contengono solo le informazioni sommarie sui contenuti dei blocchi. Ogni altra informazione richiesta dal nodo leggero viene richiesta dal nodo completo. Il nodo leggero può quindi verificare in modo indipendente i dati che riceve rispetto alle radici di stato nelle intestazioni dei blocchi. I nodi leggeri consentono agli utenti di partecipare alla rete Ethereum senza l'hardware potente o l'elevata larghezza di banda necessari per eseguire i nodi completi. Infine, i nodi leggeri potrebbero funzionare su telefoni cellulari o dispositivi embedded. I nodi leggeri non partecipano al consenso (es. non possono essere validatori/miner), ma possono accedere alla blockchain di Ethereum con la stessa sicurezza e avendo le stesse funzioni garantite ai nodi completi. -Il client di esecuzione Geth include un'opzione di [sincronizzazione leggera](https://github.com/ethereum/devp2p/blob/master/caps/les.md). Tuttavia, un nodo leggero di Geth si affida ai nodi completi che servono i dati del nodo leggero. Pochi nodi completi scelgono di servire i dati dei nodi leggeri, a significare che questi ultimi non riescono spesso a trovare pari. Al momento non esiste alcun client leggero pronto per la produzione sul livello di consenso; ce ne sono però diversi in fase di sviluppo. +I client leggeri sono un'area di sviluppo attivo per Ethereum, e ci aspettiamo presto di vedere nuovi client leggeri per i livelli di consenso e i livelli di esecuzione. Esistono anche dei percorsi potenziali per fornire i dati dei client leggeri sulla [rete di gossip](https://www.ethportal.net/). Questi sono vantaggiosi perché la rete di gossip potrebbe supportare una rete di nodi leggeri senza richiedere ai nodi completi di rispondere alle richieste. -Esistono anche dei percorsi potenziali per fornire i dati dei client leggeri sulla [rete di gossip](https://www.ethportal.net/). Questi sono vantaggiosi perché la rete di gossip potrebbe supportare una rete di nodi leggeri senza richiedere ai nodi completi di rispondere alle richieste. - -Ethereum non supporta ancora una grande popolazione di nodi leggeri, ma il supporto dei nodi leggeri è un'area in cui si prevede uno sviluppo rapido nel futuro più prossimo. +Ethereum non supporta ancora una grande popolazione di nodi leggeri, ma il supporto dei nodi leggeri è un'area in cui si prevede uno sviluppo rapido nel futuro più prossimo. In particolare, client come [Nimbus](https://nimbus.team/), [Helios](https://github.com/a16z/helios), and [LodeStar](https://lodestar.chainsafe.io/) sono attualmente fortemente focalizzati sui nodi leggeri. ### Nodo archivio {#archive-node} - Memorizza tutto ciò che è presente nel nodo completo e crea un archivio degli stati storici. È necessario se desideri consultare qualcosa come il saldo di un conto al blocco #4.000.000 o testare in modo semplice e affidabile le tue serie di transazioni, senza minarle usando il tracciamento. - Si tratta di terabyte e terabyte di dati, che rendono i nodi archivio meno attraenti per gli utenti medi, ma possono essere utili per servizi come block explorer, fornitori di portafogli e analisi della catena. -La sincronizzazione dei client in qualsiasi modalità diversa dall'archivio comporterà l'eliminazione dei dati della blockchain. Significa che non rimarrà un archivio di tutti gli stati storici, ma il nodo completo è in grado di ricostruirli su richiesta. +La sincronizzazione dei client in qualsiasi modalità diversa dall'archivio comporterà l'eliminazione dei dati della blockchain. Ciò significa che non rimarrà un archivio di tutti gli stati storici, ma il nodo completo è in grado di ricostruirli su richiesta. + +Scopri di più sui [Nodi archivio](/developers/docs/nodes-and-clients/archive-nodes). ## Perché si dovrebbe eseguire un nodo Ethereum? {#why-should-i-run-an-ethereum-node} -L'esecuzione di un nodo consente di utilizzare Ethereum in modo diretto, affidabile e privato, supportando la rete tenendola più solida e decentralizzata. +L'esecuzione di un nodo consente di utilizzare Ethereum in modo diretto, senza fiducia e privato, supportando la rete tenendola più solida e decentralizzata. ### Vantaggi per lo sviluppatore {#benefits-to-you} -Eseguire un nodo permette di utilizzare Ethereum in modo privato, autosufficiente e affidabile. Non è necessario affidarsi alla rete perché è possibile verificare i dati da soli con il proprio client. "Non fidarti, verifica" è un popolare mantra della blockchain. +Eseguire un nodo permette di utilizzare Ethereum in modo privato, autosufficiente e senza fiducia. Non è necessario affidarsi alla rete perché è possibile verificare i dati da soli con il proprio client. "Non fidarti, verifica" è un popolare mantra della blockchain. - Il nodo verifica in autonomia tutte le transazioni e i blocchi in base alle regole del consenso. Significa che non si deve fare affidamento su altri nodi della rete né fidarti completamente di loro. - Puoi usare un portafoglio Ethereum col tuo nodo. Puoi usare le dapp con maggiore sicurezza e privacy, perché non dovrai comunicare i tuoi indirizzi e saldi a nodi casuali. Tutto può essere controllato con il tuo client. [MetaMask](https://metamask.io), [Frame](https://frame.sh/)e [molti altri portafogli](/wallets/find-wallet/) offrono l'importazione RPC, consentendo loro di usare il tuo nodo. @@ -110,46 +110,46 @@ Avere una serie diversificata di nodi è importante per l'integrità, la sicurez - Più nodi sulla rete risultano in una rete più diversificata e robusta, l'obiettivo ultimo della decentralizzazione, che consente un sistema resistente alla censura e affidabile. - I nodi forniscono accesso ai dati della blockchain per i client leggeri che dipendono da essa. In caso di picchi di utilizzo, per agevolare la sincronizzazione dei nodi leggeri, è necessario che i nodi completi siano in quantità sufficiente. I nodi leggeri non memorizzano l'intera blockchain, bensì verificano i dati attraverso le [radici di stato nelle intestazioni dei blocchi](/developers/docs/blocks/#block-anatomy). Se ne hanno bisogno, possono richiedere ulteriori informazioni ai blocchi. -Se si esegue un nodo completo, l'intera rete Ethereum ne beneficia. +Se si esegue un nodo completo, l'intera rete di Ethereum ne beneficia. ## Esecuzione di un nodo proprio {#running-your-own-node} Vorresti eseguire il tuo client di Ethereum? -Per un'introduzione per principianti, visita la nostra pagina [Eseguire un nodo](/run-a-node), per saperne di più. +Per un'introduzione per i principianti, visita la nostra pagina [Eseguire un nodo](/run-a-node) per saperne di più. Se sei un utente più tecnico, approfondisci i dettagli e le opzioni su come [Avviare il tuo nodo](/developers/docs/nodes-and-clients/run-a-node/). ## Alternative {#alternatives} -Configurare un nodo può richiedere tempo e risorse e non sempre è necessario eseguire un'istanza propria. In questo caso, puoi usare un provider di API terzo, come [Infura](https://infura.io), [Alchemy](https://alchemyapi.io), [Chainstack](https://chainstack.com) o [QuikNode](https://www.quiknode.io). In alternativa, [ArchiveNode](https://archivenode.io/) è un nodo archivio finanziato dalla community che spera di portare i dati di archivio sulla blockchain Ethereum a sviluppatori indipendenti che altrimenti non potrebbero permetterselo. Per una panoramica sull'uso di questi servizi, dai un'occhiata a [nodi come servizi](/developers/docs/nodes-and-clients/nodes-as-a-service/). +Configurare un nodo può richiedere tempo e risorse e non sempre è necessario eseguire un'istanza propria. In questo caso, puoi usare un provider di API terzo. Per una panoramica sull'uso di questi servizi, dai un'occhiata a [nodi come servizi](/developers/docs/nodes-and-clients/nodes-as-a-service/). -Se qualcuno esegue un nodo di Ethereum con un'API pubblica nella tua community, puoi puntare i tuoi portafogli leggeri (come MetaMask) su un nodo della community [tramite RPC Personalizzato](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node) e ottenere maggiore privacy rispetto a quella offerta da terze parti casuali di fiducia. +Se qualcuno esegue un nodo Ethereum con un'API pubblica nella tua community, puoi puntare i tuoi portafogli a un nodo della community tramite RPC personalizzato e ottenere più privacy rispetto a terze parti fidate casuali. -D'altro canto, se esegui un client, puoi condividerlo con i amici che potrebbero averne bisogno. +D'altro canto, se esegui un client, puoi condividerlo con gli amici che potrebbero averne bisogno. ## Client d'esecuzione (ex "client di Eth1") {#execution-clients} -La community di Ethereum mantiene numerosi client di esecuzione open source (precedentemente noti come 'client di Eth1' o semplicemente 'client di Ethereum'), sviluppati da diversi team usando diversi linguaggi di programmazione. Questo rafforza la rete e la rende più [diversificata](/developers/docs/nodes-and-clients/client-diversity/). L'obiettivo ideale è raggiungere la diversità senza che nessun client prevalga, così da ridurre eventuali punti di errore singoli. +La community di Ethereum mantiene numerosi client di esecuzione open source (precedentemente noti come 'client di Eth1' o semplicemente 'client di Ethereum'), sviluppati da diversi team usando diversi linguaggi di programmazione. Questo rafforza la rete e la rende più [diversificata](/developers/docs/nodes-and-clients/client-diversity/). L'obiettivo ideale è raggiungere la diversità senza che nessun client prevalga, per ridurre eventuali punti di errore unici. Questa tabella riepiloga i diversi client. Tutti superano i [test dei client](https://github.com/ethereum/tests) e sono mantenuti attivamente per rimanere al passo con gli aggiornamenti di rete. -| Client | Linguaggio | Sistemi operativi | Reti | Strategie di sincronizzazione | Cancellazione dello stato | -| ----------------------------------------------- | ---------- | --------------------- | --------------------------------------------------------- | -------------------------------------- | ------------------------- | -| [Geth](https://geth.ethereum.org/) | Vai | Linux, Windows, macOS | Rete Principale, Sepolia, Görli, Ropsten, Rinkeby | Snap, Completa | Archiviata, Tagliata | -| [Nethermind](http://nethermind.io/) | C#, .NET | Linux, Windows, macOS | Rete Principale, Sepolia, Görli, Ropsten, Rinkeby e altre | Snap (senza servire), Rapida, Completa | Archiviata, Tagliata | -| [Besu](https://besu.hyperledger.org/en/stable/) | Java | Linux, Windows, macOS | Rete Principale, Sepolia, Görli, Ropsten, Rinkeby e altre | Rapida, Completa | Archiviata, Tagliata | -| [Erigon](https://github.com/ledgerwatch/erigon) | Go | Linux, Windows, macOS | Rete Principale, Sepolia, Görli, Rinkeby, Ropsten e altre | Completa | Archiviata, Tagliata | +| Client | Linguaggio | Sistemi operativi | Reti | Strategie di sincronizzazione | Cancellazione dello stato | +| ----------------------------------------------- | ---------- | --------------------- | ---------------------------------------- | -------------------------------------- | ------------------------- | +| [Geth](https://geth.ethereum.org/) | Vai | Linux, Windows, macOS | Rete Principale, Sepolia, Goerli | Snap, Completa | Archiviata, Tagliata | +| [Nethermind](http://nethermind.io/) | C#, .NET | Linux, Windows, macOS | Rete Principale, Sepolia, Goerli e altre | Snap (senza servire), Rapida, Completa | Archiviata, Tagliata | +| [Besu](https://besu.hyperledger.org/en/stable/) | Java | Linux, Windows, macOS | Rete Principale, Sepolia, Goerli e altre | Snap, Veloce, Completo | Archiviata, Tagliata | +| [Erigon](https://github.com/ledgerwatch/erigon) | Go | Linux, Windows, macOS | Rete Principale, Sepolia, Goerli e altre | Completa | Archiviata, Tagliata | -**Sottolineiamo che OpenEthereum [è ormai obsoleto](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) e non viene più mantenuto.** Usalo con cautela e preferibilmente passa ad un'altra implementazione client. +**Sottolineiamo che OpenEthereum [è ormai obsoleto](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) e non viene più mantenuto.** Usa un'altra implementazione client! Per ulteriori informazioni sulle reti supportate, consulta [reti Ethereum](/developers/docs/networks/). -Ogni client ha vantaggi e casi d'uso differenti, quindi è necessario sceglierne uno in base alle proprie preferenze. La diversità consente implementazioni focalizzate su diverse caratteristiche e bacini di utenti. Potresti voler scegliere un client a seconda delle funzionalità, del supporto, del linguaggio di programmazione o delle licenze. +Ogni client ha vantaggi e casi d'uso differenti, quindi è necessario sceglierne uno in base alle proprie preferenze. La diversità consente implementazioni in base alle diverse caratteristiche e al pubblico di utenti. Potresti voler scegliere un client a seconda delle funzionalità, del supporto, del linguaggio di programmazione o delle licenze. ### Besu {#besu} -Hyperledger Besu è un client Ethereum di livello aziendale per le reti pubbliche e autorizzate. Esegue tutte le funzionalità della Rete principale di Ethereum, dal monitoraggio a GraphQL, ha un monitoraggio avanzato ed è supportato da ConsensSys, entrambi in canali aperti della community e tramite SLA commerciali per le imprese. È scritto in Java con licenza Apache 2.0. +Hyperledger Besu è un client Ethereum di livello enterprise per le reti pubbliche e autorizzate. Esegue tutte le funzionalità della Rete principale di Ethereum, dal monitoraggio a GraphQL, ha un monitoraggio avanzato ed è supportato da ConsensSys, entrambi in canali aperti della community e tramite SLA commerciali per le imprese. È scritto in Java con licenza Apache 2.0. L'ampia [documentazione](https://besu.hyperledger.org/en/stable/) di Besu ti guiderà per tutti i dettagli sulle sue funzionalità e configurazioni. @@ -165,7 +165,7 @@ Scopri di più su Geth nella sua [documentazione](https://geth.ethereum.org/docs ### Nethermind {#nethermind} -Nethermind è un'implementazione di Ethereum creata con lo stack tecnologico C # .NET, concessa in licenza con LGPL-3.0, in esecuzione su tutte le principali piattaforme, incluso ARM. Offre prestazioni eccellenti con: +Nethermind è un'implementazione di Ethereum creata con lo stack tecnologico C#.NET, concessa in licenza con LGPL-3.0, in esecuzione su tutte le principali piattaforme inclusa ARM. Offre prestazioni eccellenti con: - una macchina virtuale ottimizzata - accesso allo stato @@ -175,7 +175,7 @@ Inoltre, Nethermind vanta una [documentazione dettagliata](https://docs.nethermi ## Client di consenso (ex client di "Eth2") {#consensus-clients} -Esistono diversi client di consenso (precedentemente noti come client di "Eth2") per supportare gli [aggiornamenti del consenso](/roadmap/beacon-chain/). Eseguono la Beacon Chain e forniranno il meccanismo di consenso Proof of Stake ai client di esecuzione, dopo [La Fusione](/roadmap/merge/). +Esistono diversi client di consenso (precedentemente noti come client di "Eth2") per supportare gli [aggiornamenti del consenso](/roadmap/beacon-chain/). Eseguono la Beacon Chain e forniranno il meccanismo di consenso proof-of-stake ai client di esecuzione, dopo [La Fusione](/roadmap/merge/). | Client | Lingua | Sistemi operativi | Reti | | ------------------------------------------------------------- | ---------- | --------------------- | --------------------------------------------------------------- | @@ -187,7 +187,7 @@ Esistono diversi client di consenso (precedentemente noti come client di "Eth2") ### Lighthouse {#lighthouse} -Lighthouse è un'implementazione del client di consenso scritta in Rust sotto la licenza Apache-2.0. È mantenuta da Sigma Prime ed è stabile e pronta alla produzione sin dalla genesi della Beacon Chain. È affidata a varie imprese, pool di staking e singoli individui. Mira a essere sicura, performante e interoperabile in una vasta gamma di ambienti, da PC desktop a distribuzioni automatizzate sofisticate. +Lighthouse è un'implementazione del client di consenso scritta in Rust sotto la licenza Apache-2.0. È mantenuta da Sigma Prime ed è stabile e pronta alla produzione sin dalla genesi della Beacon Chain. È affidata a varie imprese, pool di staking e singoli individui. Mira a esser sicura, performante e interoperabile in una vasta gamma di ambienti, da PC desktop a distribuzioni automatizzate sofisticate. La documentazione è consultabile nel [Libro su Lighthouse](https://lighthouse-book.sigmaprime.io/) @@ -212,13 +212,13 @@ Scopri di più nella [documentazione di Nimbus](https://nimbus.guide/) Prysm è un client di consenso completo e open source scritto in Go sotto la licenza GPL-3.0. Dispone di un'UI webapp facoltativa e da' priorità all'esperienza dell'utente, alla documentazione e alla configurabilità sia per gli utenti di staking domestico che per quelli istituzionali. -Visita la [documentazione di Prysm](https://docs.prylabs.network/docs/getting-started/) per scoprire di più. +Visita la [documentazione di Prysm](https://docs.prylabs.network/docs/getting-started/) per maggiori informazioni. ### Teku {#teku} Teku è uno dei client di genesi originali della Beacon Chain. Insieme ai soliti obiettivi (sicurezza, robustezza, stabilità, utilizzabilità, prestazioni), Teku mira specificamente a conformarsi completamente a tutti i vari standard dei client di consenso. -Teku offre opzioni di sviluppo molto flessibili. Il nodo beacon e il client del validatore possono operare insieme come un singolo processo, il che è estremamente conveniente per gli staker in autonomia, o i nodi possono operare separatamente per le operazioni di staking sofisticate. Inoltre, Teku è completamente interoperabile con [Web3Signer](https://github.com/ConsenSys/web3signer/) per firmare la sicurezza della chiave e la protezione dallo slashing. +Teku offre opzioni di distribuzione molto flessibili. Il nodo beacon e il client del validatore possono operare insieme come un singolo processo, il che è estremamente conveniente per gli staker in autonomia, o i nodi possono operare separatamente per le operazioni di staking sofisticate. Inoltre, Teku è completamente interoperabile con [Web3Signer](https://github.com/ConsenSys/web3signer/) per firmare la sicurezza della chiave e la protezione dallo slashing. Teku è scritto in Java con licenza Apache 2.0. È sviluppato dal team Protocols di ConsenSys, responsabile anche di Besu e Web3Signer. Scopri di più nella [documentazione di Teku](https://docs.teku.consensys.net/en/latest/). @@ -232,7 +232,7 @@ Le modalità di sincronizzazione rappresentano diversi approcci a questo process #### Sincronizzazione completa {#full-sync} -La sincronizzazione completa scarica tutti i blocchi (incluse intestazioni, transazioni e ricevute) e genera lo stato della blockchain in modo incrementale eseguendo ogni blocco dalla genesi. +La sincronizzazione completa scarica tutti i blocchi (incluse intestazioni, transazioni e ricevute) e genera lo stato della blockchain in modo incrementale eseguendo ogni blocco a partire dalla genesi. - Riduce al minimo la fiducia e offre la massima sicurezza verificando ogni transazione. - Al crescere del numero di transazioni, possono volerci giorni o persino settimane per elaborare tutte le transazioni. @@ -251,7 +251,9 @@ La modalità leggera del client scarica tutte le intestazioni e i dati del blocc - Ottiene solo l'ultimo stato basandosi sulla fiducia negli sviluppatori e nel meccanismo di consenso. - Client pronto all'uso con lo stato corrente della rete in pochi minuti. -[Maggiori informazioni sui client leggeri](https://www.parity.io/blog/what-is-a-light-client/) +**NB** La sincronizzazione leggera non funziona ancora con Ethereum proof-of-stake - una nuova versione verrà rilasciata presto! + +[Maggiori informazioni sui client leggeri](/developers/docs/nodes-and-clients/light-clients/) #### Sincronizzazione snap {#snap-sync} @@ -262,13 +264,7 @@ La sincronizzazione snap è l'ultimo approccio per sincronizzare un client, sper [Maggiori informazioni sulla sincronizzazione snap](https://github.com/ethereum/devp2p/blob/master/caps/snap.md) -| Client | Dimensione del disco (sincronizzazione rapida) | Dimensione del disco (archivio completo) | -| ------------ | ---------------------------------------------- | ---------------------------------------- | -| Geth | Oltre 400GB | Oltre 6TB | -| OpenEthereum | Oltre 280GB | Oltre 6TB | -| Nethermind | Oltre 500GB | Oltre 12TB | -| Besu | Oltre 750GB | Oltre 5TB | -| Erigon | N/D | Oltre 1TB | +### Modalità di sincronizzazione del livello di consenso {#consensus-layer-sync-modes} #### Sincronizzazione ottimistica {#optimistic-sync} @@ -298,5 +294,4 @@ Su internet si trovano molte informazioni sui client Ethereum. Ecco alcune risor ## Tutorial correlati {#related-tutorials} -- [Eseguire un nodo con Geth](/developers/tutorials/run-light-node-geth/) _– Come scaricare, installare ed eseguire Geth. Si parla di modalità di sincronizzazione, console di JavaScript e altro._ - [Trasforma il tuo Raspberry Pi 4 in un nodo validatore semplicemente eseguendo il flash della scheda MicroSD - Guida d'installazione](/developers/tutorials/run-node-raspberry-pi/) _ - Esegui il flash del tuo Raspberry Pi 4, collega un cavo Ethernet, connetti il disco SSD e alimenta il dispositivo per trasformare il Raspberry Pi 4 in un nodo completo di Ethereum eseguendo il livello di esecuzione (Rete principale) e/o il livello di consenso (Beacon Chain / validatore)._ diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/light-clients/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/light-clients/index.md new file mode 100644 index 00000000000..f63b0d611eb --- /dev/null +++ b/src/content/translations/it/developers/docs/nodes-and-clients/light-clients/index.md @@ -0,0 +1,61 @@ +--- +title: Client leggeri +description: Introduzione ai client leggeri di Ethereum. +lang: it +--- + +Eseguire un nodo completo è il metodo più privato, decentralizzato, senza fiducia e resistente alle censura per interagire con Ethereum. Con un nodo completo mantieni la tua copia della blockchain che può essere interrogata istantaneamente e ottieni l'accesso diretto alla rete peer-to-peer di Ethereum. Tuttavia, eseguire un nodo completo richiede una significativa quantità di memoria, archiviazione e CPU. Ciò significa che non è fattibile per tutti eseguire il proprio nodo. Esistono diverse soluzioni sulla tabella di marcia di Ethereum, inclusa l'assenza di stato, ma mancano diversi anni alla loro implementazione. La risposta nel breve termine è barattare alcuni dei vantaggi dell'esecuzione di un nodo completo per grandi miglioramenti delle prestazioni che consentono l'esecuzione di nodi con requisiti hardware molto ridotti. I nodi che permettono tale compromesso sono noti come nodi leggeri. + +## Cos'è un client leggero {#what-is-a-light-client} + +Un nodo leggero è un nodo che esegue il software di un client leggero. Invece di mantenere copie locali dei dati della blockchain e verificare in modo indipendente tutte le modifiche, richiedono i dati necessari a qualche fornitore. Il fornitore potrebbe essere una connessione diretta a un nodo completo o tramite qualche server RPC centralizzato. I dati sono quindi verificati dal nodo leggero, consentendogli di tenere il passo con la testa della catena. Il nodo leggero elabora soltanto le intestazioni del blocco, scaricando solo occasionalmente i contenuti effettivi del blocco. I nodi possono variare nella propria leggerezza, a seconda delle combinazioni di software del client leggero o completo che eseguono. Ad esempio, la configurazione più leggera sarebbe eseguire un client di esecuzione leggero e un client di consenso leggero. È inoltre probabile che molti nodi sceglieranno di eseguire client di consenso leggeri con client di esecuzione completi, o viceversa. + +## Come funzionano i client leggeri? {#how-do-light-clients-work} + +Quando Ethereum ha iniziato a utilizzare il meccanismo di consenso basato sul proof-of-stake, è stata introdotta una nuova struttura specificamente per supportare i client leggeri. Opera selezionando casualmente un sottoinsieme di 512 validatori ogni 1,1 giorni affinché agisca da **commissione di sincronizzazione**. La commissione di sincronizzazione firma l'intestazione dei blocchi recenti. L'intestazione di ogni blocco contiene la firma aggregata dei validatori nella commissione di sincronizzazione e un "bitfield" che mostra quali validatori hanno firmato e quali no. Ogni intestazione, inoltre, include un elenco dei validatori che si prevede parteciperanno alla firma del blocco successivo. Ciò significa che un client leggero può vedere rapidamente se la commissione di sincronizzazione abbia autorizzato i dati ricevuti, nonché verificare che la commissione di sincronizzazione sia quella autentica confrontando quella da cui riceve l'autorizzazione con quella che avrebbe dovuto aspettarsi secondo il blocco precedente. Così, il client leggero può continuare ad aggiornare la propria conoscenza dell'ultimo blocco di Ethereum senza scaricare effettivamente il blocco, ma soltanto l'intestazione contenente le informazioni sintetiche. + +Sul livello di esecuzione non esiste un'unica specifica per un client di esecuzione leggero. La portata di un client di esecuzione leggero può variare da una "modalità leggera" di un client di esecuzione completo, dotato di tutte le funzionalità di rete e dell'EVM di un nodo completo ma che verifica soltanto le intestazioni del blocco, senza scaricare i dati associati, o può essere un client più ridotto che fa fortemente affidamento sull'inoltro delle richieste a un fornitore RPC per interagire con Ethereum. + +## Perché i client leggeri sono importanti? {#why-are-light-clients-important} + +I client leggeri sono importanti perché consentono agli utenti di verificare i dati in entrata piuttosto che fidarsi ciecamente del fatto che il fornitore dei dati sia corretto e onesto, utilizzando soltanto una minuscola frazione delle risorse di calcolo di un nodo completo. I dati ricevuti dai client leggeri sono controllabili rispetto alle intestazioni dei blocchi che sanno essere stati firmati da almeno 2/3 di un insieme casuale di 512 validatori di Ethereum. Questa è una prova molto forte del fatto che i dati siano corretti. + +Il client leggero utilizza soltanto una minuscola quantità di potenza di calcolo, memoria e archiviazione, così che sia eseguibile su uno smartphone, incorporato in un'app o come parte di un browser. I client leggeri sono un modo per rendere l'accesso a fiducia minimizzata a Ethereum tanto privo di attrito quanto lo sarebbe fidandosi di un fornitore terzo. + +Facciamo un semplice esempio. Immagina di voler controllare il saldo del tuo conto. Per farlo, devi effettuare una richiesta a un nodo di Ethereum. Quel nodo controllerà la propria copia locale dello stato di Ethereum in cerca del tuo saldo, e te lo restituirà. Se non hai accesso diretto a un nodo, esistono degli operatori centralizzati che forniscono tali dati come servizio. Puoi inviare loro una richiesta, loro controllano il proprio nodo e ti inviano i risultati. Il problema, in questo caso, è che devi fidarti del fatto che il fornitore ti restituisca le informazioni corrette. Non puoi mai sapere davvero se le informazioni siano corrette se non puoi verificarle da solo. + +Un client leggero affronta tale problema. Anche in questo caso richiedi i dati a qualche fornitore esterno, ma quando li ricevi sono dotati di una prova che il tuo nodo leggero può verificare rispetto alle informazioni ricevute nell'intestazione del blocco. Ciò significa che Ethereum sta verificando la correttezza dei tuoi dati invece di quelli di qualche operatore fidato. + +## Quali innovazioni sono consentite dai client leggeri? {#what-innovations-do-light-clients-enable} + +Il principale vantaggio dei client leggeri è che consentono a più persone di accedere a Ethereum in modo indipendente, con requisiti di hardware trascurabili e minima dipendenza da terze parti. Ciò è un bene per gli utenti, poiché possono verificare i propri dati, ed è un bene per la rete poiché aumenta il numero e la diversità dei nodi che verificano la catena. + +La capacità di eseguire nodi di Ethereum su dispositivi con archiviazione, memoria e potenza di elaborazione molto ridotte è una delle aree principali d'innovazione sbloccate dai client leggeri. Laddove i nodi odierni di Ethereum richiedono molte risorse di calcolo, i client leggeri potrebbero essere incorporati nei browser, essere eseguiti su smartphone e forse persino su dispositivi più piccoli come smartwatch. Ciò significa che i portafogli di Ethereum con client incorporati potrebbero essere eseguiti su uno smartphone. Ciò significa che i portafogli mobili potrebbero essere molto più decentralizzati, non dovendosi fidare di fornitori di dati centralizzati per i propri dati. + +Un'estensione di ciò è abilitare i dispositivi **IoT (Internet delle Cose)**. Un client leggero potrebbe essere utilizzato per provare rapidamente la proprietà del saldo di qualche token o NFT, con tutte le garanzie di sicurezza fornite dalle commissioni di sincronizzazione, innescando qualche azione su una rete IoT. Immagina un [servizio di noleggio di biciclette](https://youtu.be/ZHNrAXf3RDE?t=929) che utilizza un'app con un client leggero incorporato per verificare rapidamente che tu possieda l'NFT del servizio di noleggio e, in tal caso, sblocca una bici che tu possa utilizzare subito! + +Anche i rollup di Ethereum beneficerebbero dei client leggeri. Uno dei grandi problemi dei rollup sono state le hack mirate ai ponti che consentono il trasferimento di fondi dalla Rete Principale di Ethereum a un rollup. Una vulnerabilità è data dagli oracoli utilizzati dai rollup per rilevare che un utente ha effettuato un deposito nel ponte. Se un oracolo alimenta dati malevoli, potrebbe indurre il rollup a pensare che si sia verificato un deposito al ponte e a rilasciare erroneamente dei fondi. Un client leggero incorporato nel rollup potrebbe essere utilizzato per proteggere dagli oracoli corrotti, poiché il deposito nel ponte potrebbe essere dotato di una prova verificabile dal rollup prima del rilascio di qualsiasi token. Lo stesso concetto potrebbe anche applicarsi ad altri ponti inter-catena. + +I client leggeri potrebbero essere anche utilizzati per aggiornare i portafogli di Ethereum. Invece di fidarsi dei dati forniti da un fornitore RPC, il tuo portafoglio potrebbe verificare direttamente i dati presentati a te utilizzando un client leggero incorporato. Ciò aggiungerebbe sicurezza al tuo portafoglio. Se il tuo fornitore RPC è stato disonesto e ti ha fornito dei dati errati, il client leggero incorporato potrebbe dirtelo! + +## Qual è lo stato attuale dello sviluppo dei client leggeri? {#current-state-of-development} + +Esistono vari client leggeri in via di sviluppo, tra cui client leggeri di esecuzione, di consenso e combinati di esecuzione/consenso. Queste sono le implementazioni di client leggeri note nel momento in cui viene scritta questa pagina: + +- [Lodestar](https://github.com/ChainSafe/lodestar/tree/unstable/packages/light-client): client leggero di consenso in TypeScript +- [Helios](https://github.com/a16z/helios): client leggero combinato di esecuzione e consenso in Rust +- [Geth](https://github.com/ethereum/go-ethereum/tree/master/light): modalità leggera per il client di esecuzione (in via di sviluppo) in Go +- [Nimbus](https://nimbus.guide/el-light-client.html): client leggero di consenso in Nim + +Per quanto ne sappiamo, nessuno è ancora considerato pronto alla produzione. + +Inoltre, c'è molto lavoro da fare per migliorare il modo in cui i client leggeri possono accedere ai dati di Ethereum. Al momento, i client leggeri si affidano alle richieste RPC ai nodi completi utilizzando un modello client/server, ma in futuro i dati potrebbero essere richiesti in un modo più decentralizzato utilizzando una rete dedicata come la [Portal Network](https://www.ethportal.net/), che potrebbe servire i dati ai client leggeri utilizzando un protocollo di gossip peer-to-peer. + +Altri punti della [tabella di marcia](/roadmap/) come gli [alberi di Verkle](/roadmap/verkle-trees/) e l'[assenza di stato](/roadmap/statelessness/) renderanno infine le garanzie di sicurezza dei client leggeri equivalenti a quelle dei client completi. + +## Letture consigliate {#further-reading} + +- [Zsolt Felfodhi sui client leggeri di Geth](https://www.youtube.com/watch?v=EPZeFXau-RE) +- [Etan Kissling sull'interconnessione dei client leggeri](https://www.youtube.com/watch?v=85MeiMA4dD8) +- [Etan Kissling sui client leggeri dopo La Fusione](https://www.youtube.com/watch?v=ZHNrAXf3RDE) +- [Piper Merriam: La strada tortuosa verso i client leggeri funzionali](https://snakecharmers.ethereum.org/the-winding-road-to-functional-light-clients/) diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/node-architecture/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/node-architecture/index.md new file mode 100644 index 00000000000..d0f5bae75c8 --- /dev/null +++ b/src/content/translations/it/developers/docs/nodes-and-clients/node-architecture/index.md @@ -0,0 +1,59 @@ +--- +title: Architettura del nodo +description: Introduzione all'organizzazione dei nodi di Ethereum. +lang: it +--- + +Un nodo di Ethereum si compone di due client: un [client di esecuzione](/developers/docs/nodes-and-clients/#execution-clients) e un [client di consenso](/developers/docs/nodes-and-clients/#consensus-clients). + +Quando Ethereum utilizzava il [proof-of-work](/developers/docs/consensus-mechanisms/pow/), un client di esecuzione era sufficiente per eseguire un intero nodo di Ethereum. Tuttavia, dall'implementazione del [proof-of-stake](/developers/docs/consensus-mechanisms/pow/), il client di esecuzione dev'essere utilizzato insieme a un altro pezzo di software detto ["client di consenso"](/developers/docs/nodes-and-clients/#consensus-clients). + +Il diagramma seguente mostra la relazione tra i due client di Ethereum. I due client si connettono alle rispettive reti peer-to-peer (P2P). Sono necessarie reti P2P separate poiché i client di esecuzione eseguono il gossip delle transazioni sulla propria rete P2P, consentendo loro di gestire il proprio pool locale di transazione, mentre i client di consenso eseguono il gossip dei blocchi sulla propria rete P2P, consentendo la crescita del consenso e della catena. + +![](node-architecture-text-background.png) + +_Quest'immagine è prestata da geth.ethereum.org e utilizza il logo di Geth per rappresentare i client di esecuzione; esistono altre opzioni per il client di esecuzione, incluse Erigon, Nethermind e Besu._ + +Perché questa struttura a due client funzioni, i client di consenso devono poter passare i pacchetti di transazioni al client di esecuzione. Eseguire le transazioni localmente è la modalità in cui il client convalida che le transazioni non violano alcuna regola di Ethereum e che l'aggiornamento proposto allo stato di Ethereum sia corretto. Similmente, quando il nodo è selezionato come produttore di un blocco, il client di consenso deve poter richiedere i pacchetti di transazioni da Geth da includere nel nuovo blocco ed eseguirli per aggiornare lo stato globale. Questa comunicazione tra client è gestita da una connessione RPC locale utilizzando l'[API del motore](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). + +## Cosa fa il client di esecuzione? {#execution-client} + +Il client di esecuzione è responsabile della gestione e del gossip delle transazioni, della gestione dello stato e del supporto alla Macchina Virtuale di Ethereum ([EVM](/developers/docs/evm/)). Tuttavia, **non** è responsabile della costruzione e del gossip dei blocchi, o della gestione della logica di consenso. Questi sono di competenza del client di consenso. + +Il client di esecuzione crea carichi utili di esecuzione: l'elenco di transazioni, l'albero di stato aggiornato e altri dati correlati all'esecuzione. I client di consenso includono il carico utile di esecuzione in ogni blocco. Il client di esecuzione è inoltre responsabile per la ri-esecuzione delle transazioni nei nuovi blocchi per assicurarsi che siano validi. L'esecuzione delle transazioni avviene sul computer incorporato del client di esecuzione, noto come [Macchina Virtuale di Ethereum (EVM)](/developers/docs/evm). + +Inoltre, il client di esecuzione offre un'interfaccia utente a Ethereum tramite i [metodi RPC](/developers/docs/apis/json-rpc) che consentono agli utenti di interrogare la blockchain di Ethereum, inviare transazioni e distribuire contratti intelligenti. È comune che le chiamate RPC siano gestite da una libreria come [Web3js](https://web3js.readthedocs.io/en/v1.8.0/), [Web3py](https://web3py.readthedocs.io/en/v5/) o da un'interfaccia utente come un portafoglio su browser. + +In sintesi, il client di esecuzione è: + +- una porta dell'utente a Ethereum +- la casa della Macchina Virtuale di Ethereum, dello stato di Ethereum e del pool di transazione. + +## Cosa fa il client di consenso? {#consensus-client} + +Il client di consenso affronta tutta la logica che consente a un nodo di rimanere sincronizzato con la rete di Ethereum. Ciò include la ricezione dei blocchi dai pari e l'esecuzione di un algoritmo di scelta della diramazione per assicurare che il nodo segua sempre la catena con la massima accumulazione di attestazioni (ponderata dai saldi effettivi del validatore). Similmente al client di esecuzione, i client di consenso hanno la propria rete P2P tramite cui condividono i blocchi e le attestazioni. + +Il client di consenso non partecipa all'attestazione o alla proposta di blocco; ciò è eseguito da un validatore, un componente aggiuntivo e facoltativo di un client di consenso. Un client di consenso senza un validatore tiene il passo soltanto con la testa della catena, consentendo al nodo di rimanere sincronizzato. Ciò consente a un utente di effettuare transazioni con Ethereum usando il proprio client di esecuzione, sicuro che si trovi sulla catena corretta. + +## Validatori {#validators} + +Gli operatori di nodi possono aggiungere un validatore ai propri client di consenso depositando 32 ETH nel contratto di deposito. Il client del validatore è raggruppato con il client di consenso e può esser aggiunto a un nodo in qualsiasi momento. Il validatore gestisce le attestazioni e le proposte dei blocchi. Consente a un nodo di maturare ricompense o perdere ETH tramite sanzioni o tagli. Eseguire un software del validatore, inoltre, rende un nodo idoneo alla selezione per proporre un nuovo blocco. + +[Maggiori informazioni sullo staking](/staking/). + +## Componenti di confronto di un nodo {#node-comparison} + +| Client di esecuzione | Client di consenso | Validatore | +| -------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ----------------------------- | +| Esegue il gossip delle transazioni tramite la propria rete P2P | Esegue il gossip di blocchi e attestazioni tramite la propria rete P2P | Propone blocchi | +| Esegue e ri-esegue le transazioni | Esegue l'algoritmo di scelta della diramazione | Matura ricompense/sanzioni | +| Verifica i cambiamenti di stato in entrata | Tiene traccia della testa della catena | Effettua le attestazioni | +| Gestisce gli alberi di stato e delle ricevute | Gestisce lo stato della Beacon (contenente le informazioni di consenso ed esecuzione) | Richiede lo staking di 32 ETH | +| Crea carico utile di esecuzione | Tiene traccia della casualità accumulata in RANDAO | Può essere tagliato | +| Espone l'API JSON-RPC per interagire con Ethereum | Tiene traccia di giustificazione e finalizzazione | | + +## Letture consigliate {#further-reading} + +- [Proof of Stake](/developers/docs/consensus-mechanisms/pos) +- [Proposta di blocco](/developers/docs/consensus-mechanisms/pos/block-proposal) +- [Ricompense e sanzioni del validatore](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties) diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/node-architecture/node-architecture-text-background.png b/src/content/translations/it/developers/docs/nodes-and-clients/node-architecture/node-architecture-text-background.png new file mode 100644 index 00000000000..1a318ac5f23 Binary files /dev/null and b/src/content/translations/it/developers/docs/nodes-and-clients/node-architecture/node-architecture-text-background.png differ diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md index 2e0e1ff1255..31f7887e00e 100644 --- a/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md +++ b/src/content/translations/it/developers/docs/nodes-and-clients/nodes-as-a-service/index.md @@ -63,55 +63,107 @@ Ecco una lista di alcuni dei più popolari fornitori di nodi Ethereum. Aggiungin - Pannello di Controllo con Request Explorer, Mempool Watcher, e Composer - Accesso integrato al faucet della rete di prova - Community Discord attiva di creatori con 18k utenti +- [**Tutti quei nodi**](https://allthatnode.com/) + - [Documentazione](https://docs.allthatnode.com/) + - Caratteristiche + - Principale livello gratuito con 150.000 richieste giornaliere + - Accesso a oltre 24 nodi della blockchain + - Endpoint RPC, HTTPS e WSS + - Accesso illimitato ai dati di archivio + - Supporto 24/7 e tempi di disponibilità fino al 99,9% + - Faucet disponibile su diverse chain + - Accesso endpoint illimitato con un numero illimitato di chiavi API + - Spazio dei nomi Trace/Debug disponibile + - Aggiornamenti automatizzati + - Supporto tecnico - [**Ankr**](https://www.ankr.com/) - [Documentazione](https://docs.ankr.com/) - Caratteristiche - - Protocollo Ankr - Accesso aperto agli endpoint dell'API di Public RPC per oltre 8 catene + - Protocollo Ankr - accesso aperto agli endpoint API RPC pubblici per oltre 8 catene - Bilanciamento del carico e monitoraggio della salute del nodo per un gateway veloce e affidabile al più vicino nodo disponibile - - Rango Premium che consente l'endpoint WSS e limite di velocità illimitato - - Distribuzione in un click del nodo completo e del suo validatore per oltre 40 catene - - Scaling al volo + - Livello premium che consente l'endpoint WSS e limite di velocità illimitato + - Distribuzione completa in un click del nodo e del suo validatore per oltre 40 catene + - Ridimensionamento secondo le esigenze - Strumenti di analisi - - Dashboard + - Pannello di controllo - RPC, HTTPS ed endpoint WSS - Assistenza diretta +- [**Blast**](https://blastapi.io/) + - [Documentazione](https://docs.blastapi.io/) + - Caratteristiche + - Supporto RPC e WSS + - Hosting multiregionale dei nodi + - Infrastruttura decentralizzata + - API pubblica + - Piano gratuito dedicato + - Supporto multicatena (oltre 17 blockchain) + - Nodi archivio + - Supporto su Discord 24/7 + - Monitoraggio e avvisi 24/7 + - Uno SLA complessivo del 99,9% + - Pagamento in criptovalute - [**BlockDaemon**](https://blockdaemon.com/) - [Documentazione](https://ubiquity.docs.blockdaemon.com/) - Vantaggi - - Dashboard + - Pannello di gestione - In base al nodo - Analisi +- [**BlockPI**](https://blockpi.io/) + - [Documentazione](https://docs.blockpi.io/) + - Caratteristiche + - Struttura del nodo robusta e distribuita + - Fino a 40 endpoint HTTPS e WSS + - Pacchetto di iscrizione gratuito e pacchetto mensile + - Metodo di tracciamento + Supporto ai dati d'archivio + - Pacchetti con validità fino a 90 giorni + - Piano personalizzato e pagamento a consumo + - Pagamento in criptovalute + - Supporto diretto e supporto tecnico - [**Chainstack**](https://chainstack.com/) - [Documentazione](https://docs.chainstack.com/) - Caratteristiche - Nodi condivisi gratuiti - Nodi d'archivio condivisi - Supporto a GraphQL - - RPC ed endpoint WSS + - Endpoint RPC e WSS - Nodi completi e d'archivio dedicati - - Tempo di sincronizzazione veloce per implementazioni dedicate - - Porta il tuo cloud - - Tariffazione oraria + - Tempo di sincronizzazione veloce per distribuzioni dedicate + - Bring your cloud + - Tariffe orarie - Assistenza diretta 24 ore su 24, 7 giorni su 7 - [**DataHub**](https://datahub.figment.io) - [Documentazione](https://docs.figment.io/) - Caratteristiche - Opzione di livello gratuito con 3.000.000 richieste/mese - - Endpoint RPC e WSS + - RPC ed endpoint WSS - Nodi completi e d'archivio dedicati - Ridimensionamento Automatico (sconti per volumi) - Dati di archiviazione gratuiti - - Analitiche del servizio - - Pannello di gestione - - Assistenza diretta 24/7 - - Pagamento in cripto (Enterprise) + - Analisi del servizio + - Dashboard + - Assistenza diretta 24 ore su 24, 7 giorni su 7 + - Pagamento in criptovalute (Enterprise) +- [DRPC](https://drpc.org/) + - [Documentazione](https://docs.drpc.org/) + - Caratteristiche + - Nodi RPC decentralizzati + - Oltre 15 fornitori di nodi + - Bilanciamento dei nodi + - Unità di calcolo illimitate al mese con il livello gratuito + - Verifica dei dati + - Endpoint personalizzati + - Endpoint http e WSS + - Chiavi illimitate (livello gratuito e a pagamento) + - Opzioni di fallback flessibili + - [Endpoint pubblico](https://eth.drpc.org) + - Nodi archivio condivisi gratuiti - [**GetBlock**](https://getblock.io/) - - [Documentazione](https://getblock.io/docs/get-started/authentication-with-api-key/) + - [Documenti](https://getblock.io/docs/get-started/authentication-with-api-key/) - Caratteristiche - Accesso a oltre 40 nodi della blockchain - 40.000 richieste giornaliere gratuite - Numero illimitato di chiavi API - - Alta velocità di connessione a 1GB/sec + - Elevata velocità di connessione a 1GB/sec - Traccia+Archivio - Analisi avanzate - Aggiornamenti automatizzati @@ -121,11 +173,11 @@ Ecco una lista di alcuni dei più popolari fornitori di nodi Ethereum. Aggiungin - Opzione livello gratuito - Ridimensionamento secondo le esigenze - Analisi - - Pannello di gestione + - Pannello di controllo - Endpoint API univoci - Nodi completi dedicati - - Tempo di sincronizzazione veloce per implementazioni dedicate - - Assistenza diretta 24/7 + - Tempo di sincronizzazione veloce per distribuzioni dedicate + - Assistenza diretta 24 ore su 24, 7 giorni su 7 - Accesso a oltre 50 nodi della blockchain - [**Infura**](https://infura.io/) - [Documentazione](https://infura.io/docs) @@ -134,23 +186,23 @@ Ecco una lista di alcuni dei più popolari fornitori di nodi Ethereum. Aggiungin - Ridimensionamento secondo le esigenze - Dati di archiviazione a pagamento - Assistenza diretta - - Pannello di gestione + - Pannello di controllo - [**Kaleido**](https://kaleido.io/) - - [Documentazione](https://docs.kaleido.io/) + - [Documenti](https://docs.kaleido.io/) - Caratteristiche - Livello iniziale gratuito - - Distribuzione del nodo di Ethereum in un click + - Distribuzione del nodo di Ethereum in un clic - Client e algoritmi personalizzabili (Geth, Quorum e Besu || PoA, IBFT e Raft) - Oltre 500 API amministrative e di servizio - - Interfaccia di RESTful per l'invio di transazioni di Ethereum (basata su Apache Kafka) - - Flussi in uscita per la consegna degli eventi (basata su Apache Kafka) + - Interfaccia RESTful per l'invio di transazioni di Ethereum (supportata da Apache Kafka) + - Flussi in uscita per la consegna degli eventi (supportati da Apache Kafka) - Raccolta approfondita di servizi "off-chain" e ausiliari (es. trasporto bilaterale di messaggistica crittografata) - - Semplice rete di integrazione con governance e controllo dell'accesso basato sul ruolo - - Gestione dell'utente sofisticata per amministratori e utenti finali - - Infrastruttura altamente scalabile, resiliente e di livello aziendale + - Semplice integrazione di rete con governance e controllo dell'accesso basato sul ruolo + - Sofisticata gestione dell'utente per amministratori e utenti finali + - Infrastruttura altamente scalabile, resiliente e di livello enterprise - Gestione delle chiavi private HSM del cloud - - Tethering della rete principale di Ethereum - - Certificazioni ISO 27k e SOC 2, Type 2 + - Tethering della Rete Principale di Ethereum + - Certificazioni ISO 27k e SOC 2, di Tipo 2 - Configurazione di runtime dinamica (es. aggiungere integrazioni del cloud, alterare gli ingressi del nodo, ecc.) - Supporto per orchestrazioni multi-cloud, multiregionali e con distribuzione ibrida - Tariffe orarie semplici basate su Saas @@ -159,54 +211,61 @@ Ecco una lista di alcuni dei più popolari fornitori di nodi Ethereum. Aggiungin - [Documenti](https://docs.moralis.io/) - Caratteristiche - Nodi condivisi gratuiti - - Nodi di archiviazione condivisi gratuiti + - Nodi archivio condivisi gratuiti - Incentrato sulla privacy (nessuna politica sui registri) - Supporto tra catene - Ridimensionamento secondo le esigenze - - Pannello di gestione - - SDK Ethereum unico + - Pannello di controllo + - SDK Ethereum univoco - Endpoint API univoci - Supporto tecnico diretto +- [**NodeReal MegaNode**](https://nodereal.io/) + - [Documentazione](https://docs.nodereal.io/nodereal/meganode/introduction) + - Caratteristiche + - Servizi API RPC affidabili, veloci e scalabili + - API migliorata per sviluppatori web3 + - Supporto multi-catena + - Inizia gratuitamente - [**NOWNodes**](https://nownodes.io/) - [Documentazione](https://documenter.getpostman.com/view/13630829/TVmFkLwy) - Caratteristiche - Accesso a oltre 50 nodi della blockchain - - Chiave API Gratuita - - Esploratori di blocchi + - Chiave API gratuita + - Block Explorer - Tempo di risposta dell'API ⩽ 1 sec - - Team di supporto 24/7 - - Gestore Personale del Conto + - Team di assistenza 24/7 + - Referente commerciale personale - Nodi condivisi, archivio, backup e dedicati - [**Pocket Network**](https://www.pokt.network/) - [Documentazione](https://docs.pokt.network/home/) - Caratteristiche - Protocollo RPC e Marketplace decentralizzati - - 1 milione di richieste giornaliere gratuite (per endpoint, max. 2) + - Livello con 1 milione di richieste giornaliere gratuite (per endpoint, max. 2) - [Endpoint pubblici](https://docs.pokt.network/home/resources/public-rpc-endpoints) - Programma Pre-Stake+ (se servono più di 1 milione di richieste al giorno) - Più di 15 blockchain supportate - Più di 6.400 nodi che guadagnano POKT a servizio delle applicazioni - Nodo d'archiviazione, nodo d'archiviazione con tracciamento e supporto ai nodi di reti di prova - - Diversità dei client dei nodi della rete principale di Ethereum - - Nessun Single Point of Failure - - Nessun tempo d'inattività + - Diversità dei client dei nodi della Rete Principale di Ethereum + - Nessun punto di errore unico + - Nessun tempo di inattività - Tokenomic a bassissimo costo (esegui lo staking di POKT una volta per la larghezza di banda di rete) - Nessun costo mensile irrecuperabile, trasforma la tua infrastruttura in una risorsa - Bilanciamento di carico integrato nel protocollo - - Ridimensiona progressivamente e in modo preciso il numero di richieste giornaliere e nodi orari + - Ridimensiona illimitatamente il numero di richieste giornaliere e nodi orari in base alle esigenze - L'opzione più privata e resistente alla censura - Supporto pratico per sviluppatori - - Dashboard e analisi di [Pocket Portal](https://bit.ly/ETHorg_POKTportal) + - Pannello di controllo e analisi di [Pocket Portal](https://bit.ly/ETHorg_POKTportal) - [**QuickNode**](https://www.quicknode.com) - - [Documenti](https://www.quicknode.com/docs/) + - [Documentazione](https://www.quicknode.com/docs/) - Caratteristiche - Riferimento nel settore per prestazioni e affidabilità - Supporto tecnico 24/7 e community Discord di sviluppatori - Bilanciamento geografico, multi-cloud/metal, rete a bassa latenza - Supporto multi-catena (Optimism, Arbitrum, Polygon e altri 11) - - Livelli intermedi (middle layer) per velocità e stabilità (indirizzamento di chiamata, cache, indicizzazione) + - Livelli intermedi per velocità e stabilità (indirizzamento di chiamata, cache, indicizzazione) - Monitoraggio del contratto intelligente tramite Webhook - - Pannello di controllo intuitivo, suite di analisi, RPC composer + - Pannello di controllo intuitivo, suite di analisi, compositore RPC - Funzionalità di sicurezza avanzate (JWT, mascheratura, whitelist) - API di dati e analisi NFT - [Certificazione SOC2](https://www.quicknode.com/security) @@ -217,14 +276,14 @@ Ecco una lista di alcuni dei più popolari fornitori di nodi Ethereum. Aggiungin - Opzione livello gratuito - Ridimensionamento secondo le esigenze - [**SenseiNode**](https://senseinode.com) - - [Documentazione](https://docs.senseinode.com/) + - [Docs](https://docs.senseinode.com/) - Caratteristiche - Nodi dedicati e condivisi - - Pannello di gestione + - Pannello di controllo - Hosting di AWS su diversi fornitori di hosting in diversi luoghi in America Latina - Client di Prysm e Lighthouse - [**SettleMint**](https://console.settlemint.com/) - - [Documentazione](https://docs.settlemint.com/) + - [Docs](https://docs.settlemint.com/) - Caratteristiche - Prova gratuita - Ridimensionamento secondo le esigenze @@ -232,37 +291,63 @@ Ecco una lista di alcuni dei più popolari fornitori di nodi Ethereum. Aggiungin - Endpoint RPC e WSS - Nodi completi dedicati - Bring your cloud - - Strumenti d'analisi - - Pannello di gestione + - Strumenti di analisi + - Pannello di controllo - Tariffe orarie - Assistenza diretta +- [**Tenderly**](https://tenderly.co/web3-gateway) + - [Docs](https://docs.tenderly.co/web3-gateway/web3-gateway) + - Caratteristiche + - Livello gratuito con 25 milioni di Unità di Tenderly al mese + - Accesso gratuito ai dati storici + - Carichi di lavoro gravosi in lettura fino a 8 volte più veloci + - Accesso di lettura coerente al 100% + - Endpoint RPC JSON + - Costruttore di richieste RPC basato sull'UI e anteprima della richiesta + - Completamente integrato con gli strumenti di sviluppo, debug e test di Tenderly + - Simulazioni delle transazioni + - Analisi di utilizzo e filtraggio + - Facile gestione delle chiavi d'accesso + - Supporto ingegneristico dedicato tramite chat, email e Discord - [**Watchdata**](https://watchdata.io/) - - [Documentazione](https://docs.watchdata.io/) + - [Docs](https://docs.watchdata.io/) - Caratteristiche - Attendibilità dei dati - - Connessione ininterrotta senza tempi d'inattività - - Automatizzazione di processo + - Connessione ininterrotta senza tempi di inattività + - Automazione di processo - Tariffe gratuite - Limiti elevati che si adattano a qualsiasi utente - Supporto per vari nodi - Ridimensionamento delle risorse - Velocità d'elaborazione elevate - [**ZMOK**](https://zmok.io/) - - [Documentazione](https://docs.zmok.io/) + - [Documenti](https://docs.zmok.io/) - Caratteristiche - Front-running come servizio - Mempool di transazioni globale con metodi di ricerca/filtraggio - - Commissione TX illimitata e Gas infinito per inviare le transazioni + - Commissione TX illimitata e carburante infinito per inviare le transazioni - Ottenimento più veloce del nuovo blocco e lettura della blockchain - Il miglior prezzo per garanzia di chiamata dell'API +[**Zeeve**](https://www.zeeve.io/) + +- [Documenti](https://www.zeeve.io/docs/) +- Caratteristiche + - Piattaforma di automazione senza codice di livello enterprise che fornisce la distribuzione, il monitoraggio e la gestione dei nodi e delle reti Blockchain + - Oltre 30 protocolli e integrazioni supportati, e altri in arrivo + - Servizi dell'infrastruttura web3 dal valore aggiunto, quali archiviazione decentralizzata, identità decentralizzata e API dei dati del Libro Mastro della Blockchain per casi d'uso del mondo reale + - Supporto 24/7 e monitoraggio proattivo assicurano la costante salute dei nodi. + - Gli endpoint RPC offrono un accesso autenticato alle API, una gestione dei servizi senza sforzo con un pannello di controllo intuitivo e analisi dei dati. + - Offre opzioni di cloud gestito e di bring your own cloud tra cui scegliere e supporta tutti i principali fornitori di cloud come AWS, Azure, Google Cloud, Digital Ocean e on-premise. + - Utilizziamo l'instradamento intelligente per colpire sempre il nodo più vicino al tuo utente + ## Letture consigliate {#further-reading} -- [List of Ethereum node services](https://ethereumnodes.com/) +- [Elenco di servizi di nodi Ethereum](https://ethereumnodes.com/) ## Argomenti correlati {#related-topics} -- [Nodi e client](/developers/docs/nodes-and-clients/) +- [ Nodi e client](/developers/docs/nodes-and-clients/) ## Tutorial correlati {#related-tutorials} diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/nodes.png b/src/content/translations/it/developers/docs/nodes-and-clients/nodes.png new file mode 100644 index 00000000000..4da20f7131e Binary files /dev/null and b/src/content/translations/it/developers/docs/nodes-and-clients/nodes.png differ diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/diagram.png b/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/diagram.png new file mode 100644 index 00000000000..7ca20fac2db Binary files /dev/null and b/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/diagram.png differ diff --git a/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/index.md b/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/index.md index ba28d254661..0244dc60132 100644 --- a/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/index.md +++ b/src/content/translations/it/developers/docs/nodes-and-clients/run-a-node/index.md @@ -43,18 +43,12 @@ I client di Ethereum possono funzionare su computer di livelo consumer e non ric - Il compromesso è doversi affidare a una terza parte: il fornitore del server - A causa della dimensione d'archiviazione richiesta per il nodo completo, il prezzo di un server affittato potrebbe essere alto - Hardware proprio - - Approccio più affidabile e autonomo + - Approccio più autonomo e senza fiducia - Investimento una tantum - Possibilità di acquistare macchine pre-configurate - Devi preparare, mantenere e potenzialmente risolvere i problemi della macchina e di rete, fisicamente -Le due opzioni presentano vantaggi differenti, sopra riassunti. Se cerchi una soluzione su cloud, oltre a molti fornitori informatici di cloud tradizionali, esistono anche servizi incentrati sulla distribuzione dei nodi. Per esempio: - -- [QuikNode](https://www.quiknode.io/) -- [Blockdaemon](https://blockdaemon.com) -- [Alchemy](https://www.alchemy.com/) - -Dai anche un'occhiata a [nodi come servizi](/developers/docs/nodes-and-clients/nodes-as-a-service/) per ulteriori opzioni sui nodi ospitati. +Le due opzioni presentano vantaggi differenti, sopra riassunti. Se cerchi una soluzione su cloud, oltre a molti fornitori informatici di cloud tradizionali, esistono anche servizi incentrati sulla distribuzione dei nodi. Dai anche un'occhiata a [nodi come servizi](/developers/docs/nodes-and-clients/nodes-as-a-service/) per ulteriori opzioni sui nodi ospitati. #### Hardware {#hardware} @@ -66,32 +60,32 @@ Usare il tuo hardware può essere molto facile. Esistono molte opzioni semplici, #### Requisiti {#requirements} -I requisiti hardware differiscono in base al client, ma in genere non sono particolarmente elevati dal momento che il nodo deve solo rimanere sincronizzato. Non va confuso con il mining, che invece richiede molta più potenza di calcolo. Il tempo di sincronizzazione e le prestazioni ovviamente migliorano con hardware più potente. +I requisiti hardware differiscono in base al client, ma in genere non sono così elevati dal momento che il nodo deve solo rimanere sincronizzato. Non va confuso con il mining, che invece richiede molta più potenza di calcolo. Il tempo di sincronizzazione e le prestazioni naturalmente migliorano con hardware più potente. Prima di installare qualsiasi client, assicurati che il tuo computer abbia abbastanza risorse per eseguirlo. Puoi trovare i requisiti minimi e consigliati di seguito. L'ostacolo per il tuo hardware è principalmente lo spazio su disco. Sincronizzare la blockchain Ethereum richiede molte risorse in ingresso/uscita e richiede molto spazio. È meglio avere un **disco a stato solido (SSD)**, con centinaia di GB di spazio libero risparmiati anche dopo la sincronizzazione. -Le dimensioni del database e la velocità della sincronizzazione iniziale dipendono dal client scelto, dalla sua configurazione e [strategia di sincronizzazione](/developers/docs/nodes-and-clients/#sync-modes). +Le dimensioni del database e la velocità della sincronizzazione iniziale dipendono dal client scelto, dalla sua configurazione e dalla [strategia di sincronizzazione](/developers/docs/nodes-and-clients/#sync-modes). Assicurati anche che la tua connessione a internet non sia limitata da un [limite di larghezza di banda](https://wikipedia.org/wiki/Data_cap). Si consiglia di non usare una connessione a consumo poiché la sincronizzazione iniziale e i dati trasmessi alla rete potrebbero superare il limite di traffico. -##### Sistema operativo {#operating-system} +##### Sistema operativo -Tutti i client supportano i principali sistemi operativi: Linux, MacOS, Windows. Questo significa che puoi eseguire i nodi su macchine desktop o server ordinarie, con il sistema operativo (OS) più adatto alle tue esigenze. Assicurati che il tuo OS sia aggiornato per evitare potenziali problemi e vulnerabilità di sicurezza. +Tutti i client supportano i principali sistemi operativi: Linux, MacOS, Windows. Questo significa che puoi eseguire i nodi su macchine desktop o server ordinarie con il sistema operativo (OS) più adatto alle tue esigenze. Assicurati che il tuo OS sia aggiornato per evitare possibili problemi e vulnerabilità di sicurezza. -##### Requisiti minimi {#minimum-requirements} +##### Requisiti minimi - CPU con 2+ core - 8 GB di RAM -- 700GB di spazio libero su disco +- 2TB di SSD - Larghezza di banda 10+ MBit/s -##### Specifiche raccomandate {#recommended-hardware} +##### Specifiche raccomandate - CPU veloce con 4+ core -- 16 GB+ RAM -- SSD veloce con 1+ TB +- 16 GB+ di RAM +- SSD veloce con 2+ TB - Larghezza di banda 25+ MBit/s La modalità di sincronizzazione e il client che scegli influenzeranno i requisiti di spazio ma abbiamo stimato lo spazio su disco che ti servirà per ogni client di seguito. @@ -132,28 +126,29 @@ Diversi progetti intuitivi mirano a migliorare l'esperienza di configurazione di Di seguito trovi alcuni progetti che possono aiutarti a installare e controllare i client in pochi click: -- [DappNode](https://docs.dappnode.io/get-started/installation/custom-hardware/installation/overview/) - DappNode non è fornito solo con una macchina da un fornitore. Il software, il launcher del nodo vero e proprio e il centro di controllo con molte funzionalità, sono utilizzabili su hardware arbitrario. -- [eth-docker](https://eth-docker.net/docs/About/Overview/) - La configurazione automatizzata usando Docker, incentrata sullo staking facile e sicuro, richiede una conoscenza di base del terminale e di Docker, consigliata per gli utenti un po' più avanzati. +- [DappNode](https://docs.dappnode.io/user/quick-start/first-steps/) - DappNode non è fornito solo con una macchina da un fornitore. Il software, il launcher del nodo vero e proprio e il centro di controllo con molte funzionalità, sono utilizzabili su hardware arbitrario. +- [eth-docker](https://eth-docker.net/) - La configurazione automatizzata usando Docker, incentrata sullo staking facile e sicuro, richiede una conoscenza di base del terminale e di Docker, consigliata per gli utenti un po' più avanzati. - [Stereum](https://stereum.net/ethereum-node-setup/) - Launcher per installare i client su un server remoto tramite connessione SSH con una guida di configurazione con GUI, un centro di controllo e molte altre funzionalità. - [NiceNode](https://www.nicenode.xyz/) - Launcher con un'esperienza utente semplice per eseguire un nodo sul tuo computer. Basta scegliere i client e avviarli in pochi clic. Ancora in fase di sviluppo. +- [Sedge](https://docs.sedge.nethermind.io/docs/intro): Strumento di configurazione del nodo che genera automaticamente la configurazione di un Docker utilizzando la procedura guidata della CLI. Scritta in Go da Nethermind. ### Configurazione manuale dei client {#manual-setup} L'altra opzione è scaricare, verificare e configurare manualmente il software del client. Anche se alcuni client offrono un'interfaccia grafica, una configurazione manuale richiede comunque abilità essenziali col terminale, ma offre una versatilità molto maggiore. -Come spiegato prima, configurare il tuo nodo di Ethereum richiederà l'esecuzione di una coppia di client di consenso e di esecuzione. Alcuni client potrebbero includere un client leggero dell'altro tipo e sincronizzarsi senza che sia necessario altro software. Tuttavia, la verifica completa e affidabile richiede entrambe le implementazioni. +Come spiegato prima, configurare il tuo nodo di Ethereum richiederà l'esecuzione di una coppia di client di consenso e di esecuzione. Alcuni client potrebbero includere un client leggero dell'altro tipo e sincronizzarsi senza che sia necessario altro software. Tuttavia, la verifica senza fiducia e completa richiede entrambe le implementazioni. #### Ottenere il software del client {#getting-the-client} Prima di tutto devi ottenere il software dei tuoi [client di esecuzione](/developers/docs/nodes-and-clients/#execution-clients) e [client di consenso](developers/docs/nodes-and-clients/#consensus-clients) preferiti. -Puoi semplicemente scaricare un'applicazione eseguibile o pacchetto d'installazionepiù adatto al tuo sistema operativo e alla tua architettura. Verifica sempre le firme e le checksum dei pacchetti scaricati. Alcuni client offrono anche repository o immagini Docker per facilitare l’installazione e gli aggiornamenti. Tutti i client sono open source, quindi puoi anche compilarli da sorgente. Questo è un metodo più avanzato ma, in alcuni casi, potrebbe esser richiesto. +Puoi semplicemente scaricare un'applicazione eseguibile o pacchetto d'installazione più adatto al tuo sistema operativo e alla tua architettura. Verifica sempre le firme e le checksum dei pacchetti scaricati. Alcuni client offrono anche repository o immagini Docker per facilitare l’installazione e gli aggiornamenti. Tutti i client sono open source, quindi puoi anche compilarli da sorgente. Questo è un metodo più avanzato ma, in alcuni casi, potrebbe esser richiesto. Le istruzioni per installare ogni client sono fornite nella documentazione collegata nei suddetti elenchi di client. Ecco le pagine delle release dei client, in cui puoi trovare i loro binari precompilati o le istruzioni d'installazione: -##### Client di esecuzione {#execution-clients} +##### Client di esecuzione - [Besu](https://github.com/hyperledger/besu/releases) - [Erigon](https://github.com/ledgerwatch/erigon#usage) (Non fornisce un binario precompilato, dev'essere compilato) @@ -162,7 +157,7 @@ Ecco le pagine delle release dei client, in cui puoi trovare i loro binari preco Vale anche la pena notare che la diversità dei client è un [problema sul livello di esecuzione](/developers/docs/nodes-and-clients/client-diversity/#execution-layer). Si consiglia ai lettori di considerare l'esecuzione di un client di esecuzione di minoranza. -##### Client di consenso {#consensus-clients} +##### Client di consenso - [Lighthouse](https://github.com/sigp/lighthouse/releases/latest) - [Lodestar](https://chainsafe.github.io/lodestar/install/source/) (Non fornisce un binario precompilato, solo un'immagine Docker o da compilare da sorgente) @@ -174,13 +169,13 @@ La [diversità del client](/developers/docs/nodes-and-clients/client-diversity/) [Visualizza l'uso più recente del client della rete](https://clientdiversity.org/) e scopri di più sulla [diversità dei client](/developers/docs/nodes-and-clients/client-diversity). -##### Verificare il software {#verifying-the-software} +##### Verificare il software Quando si scarica il software da Internet, si consiglia di verificarne l'integrità. Questo passaggio è facoltativo, ma specialmente con parti di infrastruttura essenziali come il client di Ethereum, è importante esser consapevoli dei potenziali vettori d'attacco ed evitarli. Se hai scaricato un binario precompilato, devi fidartene e rischiare che un utente malevolo possa scambiare l'eseguibile con un file malevolo. Gli sviluppatori firmano i binari rilasciati con le loro chiavi PGP, così che tu possa verificare crittograficamente che stai eseguendo esattamente il software che hanno creato. Devi solo ottenere le chiavi pubbliche usate dagli sviluppatori, che si possono trovare sulle pagine di rilascio del client o nella documentazione. Dopo aver scaricato la release del client e la sua firma, puoi usare un'implementazione di PGP, es. [GnuPG](https://gnupg.org/download/index.html) per verificarli facilmente. Dai un'occhiata a un tutorial sulla verifica del software open source usando `gpg` su [linux](https://www.tecmint.com/verify-pgp-signature-downloaded-software/) o su [Windows/MacOS](https://freedom.press/training/verifying-open-source-software/). -Un'altra forma di verifica è assicurarsi che l'hash, un'impronta digitale crittografica univoca, del software scaricato corrisponda a quello fornito dagli sviluppatori. Ciò è persino più facile che usare PGP, e alcuni client offrono solo quest'opzione. Basta eseguire la funzione di hash sul software scaricato e confrontarla con quella dalla pagina di rilascio. Per esempio: +Un'altra forma di verifica è assicurarsi che l'hash, un'impronta digitale crittografica univoca, del software scaricato corrisponda a quello fornito dagli sviluppatori. Ciò è persino più facile che usare PGP, e alcuni client offrono solo quest'opzione. Basta eseguire la funzione di hash sul software scaricato e confrontarla con quella dalla pagina di rilascio. Ad esempio: ``` sha256sum teku-22.6.1.tar.gz @@ -233,7 +228,7 @@ Questa sezione ti guiderà nell'avvio dei client di esecuzione. Serve solo da es - Abilita le interfacce per comunicare col client - Inclusi l'API di JSON RPC e l'API Engine per la comunicazione col client di consenso - Definisce il percorso a `jwtsecret` per l'API autenticata - - Assicurati di sostituire il percorso d'esempio con quello reale, accessibile dai client, es. `/tmp/jwtsecret` + - Assicurati di sostituire il percorso d'esempio con quello reale accessibile dai client, es. `/tmp/jwtsecret` Ricordati che questo è solo un esempio di base, tutte le altre impostazioni saranno predefinite. Presta attenzione alla documentazione di ogni client per conoscere i valori predefiniti, le impostazioni e le funzionalità. Per ulteriori funzionalità, ad esempio per eseguire i validatori, per il monitoraggio, ecc., fai riferimento alla documentazione del client specifico. @@ -281,12 +276,13 @@ Questo esempio avvia Geth sulla rete principale, memorizza i dati della blockcha ``` geth --mainnet \ --datadir "/data/ethereum" \ - --http --http.api="eth,web3,net" \ + --http --authrpc.addr localhost \ --authrpc.vhosts="localhost" \ + --authrpc.port 8551 --authrpc.jwtsecret=/path/to/jwtsecret ``` -Controlla la [documentazione per tutte le opzioni di configurazione](https://geth.ethereum.org/docs/interface/command-line-options) e scopri di più sull'[esecuzione di Geth con un client di consenso](https://geth.ethereum.org/docs/interface/consensus-clients). +Controlla la [documentazione per tutte le opzioni di configurazione](https://geth.ethereum.org/docs/fundamentals/command-line-options) e scopri di più sull'[esecuzione di Geth con un client di consenso](https://geth.ethereum.org/docs/getting-started/consensus-clients). ##### Eseguire Nethermind @@ -302,7 +298,7 @@ La documentazione di Nethermind offre una [guida completa](https://docs.nethermi Il client di esecuzione avvierà le sue funzioni principali, gli endpoint scelti e inizierà a cercare i pari. Dopo aver scoperto correttamente i pari, il client avvia la sincronizzazione. Il client di esecuzione attenderà una connessione dal client di consenso. I dati correnti della blockchain saranno disponibili una volta che il client è sincronizzato correttamente allo stato corrente. -#### Avviare il client del consenso {#starting-the-consensus-client} +#### Avviare il client di consenso {#starting-the-consensus-client} Il client di consenso deve essere avviato con la configurazione della porta corretta, per stabilire una connessione RPC locale al client di esecuzione. I client di consenso devono essere eseguiti con la porta del client di esecuzione esposta come argomento di configurazione. @@ -312,19 +308,19 @@ Se pianifichi di eseguire un validatore, assicurati di aggiungere un flag di con Avviando il Nodo Beacon sulla rete di prova, puoi risparmiare parecchio tempo di sincronizzazione usando l'endpoint pubblico per la [Sincronizzazione del punto di controllo](https://notes.ethereum.org/@launchpad/checkpoint-sync). -#### Eseguire un client del consenso +#### Eseguire un client di consenso ##### Eseguire Lighthouse Prima di eseguire Lighthouse, scopri di più su come installarlo e configurarlo nel [Libro su Lighthouse](https://lighthouse-book.sigmaprime.io/installation.html). ``` -lighthouse beacon_node +lighthouse beacon_node \ --network mainnet \ --datadir /data/ethereum \ --http \ --execution-endpoint http://127.0.0.1:8551 \ - --execution-jwt /path/to/jwtsecret \ + --execution-jwt /path/to/jwtsecret ``` ##### Eseguire Lodestar @@ -358,7 +354,7 @@ Prysm è dotato di uno script che consente una facile installazione automatica. ``` ./prysm.sh beacon-chain \ - --mainnet + --mainnet \ --datadir /data/ethereum \ --execution-endpoint=http://localhost:8551 \ --jwt-secret=/path/to/jwtsecret @@ -370,16 +366,16 @@ Prysm è dotato di uno script che consente una facile installazione automatica. teku --network mainnet \ --data-path "/data/ethereum" \ --ee-endpoint http://localhost:8551 \ - --ee-jwt-secret-file "/path/to/jwtsecret" \ + --ee-jwt-secret-file "/path/to/jwtsecret" ``` -Quando un client di consenso si connette al client di esecuzione per leggere il contratto di deposito e identificare i validatori, si connette anche ad altri pari del Nodo Beacon e avvia la sincronizzazione degli slot del consenso dalla genesi. Una volta che il Nodo Beacon raggiunge l'epoca corrente, l'API Beacon diventa utilizzabile per i tuoi validatori. Scopri di più sulle [API del Nodo Beacon](https://eth2docs.vercel.app/). +Quando un client di consenso si connette al client di esecuzione per leggere il contratto di deposito e identificare i validatori, si connette anche ad altri pari del Nodo Beacon e avvia la sincronizzazione degli slot di consenso dalla genesi. Una volta che il Nodo Beacon raggiunge l'epoca corrente, l'API Beacon diventa utilizzabile per i tuoi validatori. Scopri di più sulle [API del Nodo Beacon](https://eth2docs.vercel.app/). ### Aggiungere Validatori {#adding-validators} Un client di consenso funge da Nodo Beacon a cui si connettono i validatori. Ogni client di consenso ha il proprio software del validatore, descritto nei dettagli nella rispettiva documentazione. -Eseguire il proprio validatore consente lo [staking in autonomia](https://ethereum.org/en/staking/solo/), il metodo più d'impatto e affidabile per supportare la rete di Ethereum. Tuttavia, ciò richiede un deposito di 32 ETH. Per eseguire un validatore sul tuo nodo con un importo inferiore, potrebbe interessarti un pool decentralizzato con operatori del nodo privi di autorizzazioni, come [Rocket Pool](https://rocketpool.net/node-operators). +Eseguire il proprio validatore consente lo [staking in autonomia](https://ethereum.org/en/staking/solo/), il metodo più d'impatto e senza fiducia per supportare la rete di Ethereum. Tuttavia, ciò richiede un deposito di 32 ETH. Per eseguire un validatore sul tuo nodo con un importo inferiore, potrebbe interessarti un pool decentralizzato con operatori del nodo privi di autorizzazioni, come [Rocket Pool](https://rocketpool.net/node-operators). Il metodo più facile per iniziare con lo staking e generare la chiave del validatore è usare il [Launchpad di Staking della Rete di Prova di Goerli](https://goerli.launchpad.ethereum.org/), che ti consente di testare la tua configurazione, [eseguendo i nodi su Goerli](https://notes.ethereum.org/@launchpad/goerli). Quando sei pronto per la Rete Principale, puoi ripetere questi passaggi usando il [Launchpad di Staking della Rete Principale](https://launchpad.ethereum.org/). @@ -390,10 +386,10 @@ Dai un'occhiata alla [pagina sullo staking](/staking) per una panoramica sulle o I client di esecuzione offrono gli [endpoint dell'API RPC](/developers/docs/apis/json-rpc/) che puoi usare per inviare le transazioni, interagire con o distribuire i contratti intelligenti sulla rete Ethereum in vari modi: - Effettuare una chiamata manuale con un protocollo adatto (es. usando `curl`) -- Allegare una console fornita (es. `geth attach`) +- Collegare una console fornita (es. `geth attach`) - Implementarli nelle applicazioni usando le librerie web3, es. [web3.py](https://web3py.readthedocs.io/en/stable/overview.html#overview), [ethers](https://github.com/ethers-io/ethers.js/) -Client diversi hanno implementazioni diverse degli endpoint RPC. Ma esiste uno standard JSON-RPC che puoi utilizzare con ogni client. Per una panoramica, [leggi la documentazione di JSON-RPC](/developers/docs/apis/json-rpc/). Le applicazioni che necessitano di informazioni dalla rete di Ethereum possono usare questa RPC. Ad esempio, il popolare portafoglio MetaMask ti consente di [connetterti al tuo endpoint RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node), con forti vantaggi in termini di privacy e la sicurezza. +Client diversi hanno implementazioni diverse degli endpoint RPC. Ma esiste uno standard JSON-RPC che puoi utilizzare con ogni client. Per una panoramica, [leggi la documentazione di JSON-RPC](/developers/docs/apis/json-rpc/). Le applicazioni che necessitano di informazioni dalla rete Ethereum possono usare questa RPC. Ad esempio, il popolare portafoglio MetaMask ti consente di [connetterti al tuo endpoint RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node), con forti vantaggi in termini di privacy e la sicurezza. I client di consenso espongono tutti l'[API Beacon](https://ethereum.github.io/beacon-APIs) utilizzabile per verificare lo stato del client di consenso o per scaricare blocchi e dati di consenso, inviando richieste usando strumenti come [Curl](https://curl.se). Maggiori informazioni a riguardo si possono trovare nella documentazione di ogni client di consenso. @@ -409,9 +405,9 @@ L'accesso all'interfaccia RPC può essere esteso tramite lo sviluppo di API del Configurare un server web, un proxy o l'API Rest rivolta all'esterno non è il solo modo per fornire accesso all'endpoint RPC del tuo nodo. Un altro metodo a tutela della privacy per configurare un endpoint raggiungibile pubblicamente è ospitare il nodo sul tuo servizio onion di [Tor](https://www.torproject.org/). Questo ti consentirà di raggiungere l'RPC al di fuori della tua rete locale senza un indirizzo IP pubblico statico o aprire le porte. Tuttavia, utilizzare questa configurazione potrebbe rendere l'endpoint RPC accessibile solo tramite la rete di Tor, che non è supportata da tutte le applicazioni e potrebbe risultare in problemi di connessione. -Per farlo, devi creare il tuo [servizio di onion](https://community.torproject.org/onion-services/). Dai un'occhiata [alla documentazione](https://community.torproject.org/onion-services/setup/) sulla configurazione del servizio di onion per ospitare il tuo. Puoi puntarlo a un server web con proxy alla porta RPC o, semplicemente, direttamente all'RPC. +Per farlo, devi creare il tuo [servizio di onion](https://community.torproject.org/onion-services/). Dai un'occhiata [alla documentazione](https://community.torproject.org/onion-services/setup/) sulla configurazione del servizio onion per ospitare il tuo. Puoi puntarlo a un server web con proxy alla porta RPC o, semplicemente, direttamente all'RPC. -Infine, uno dei metodi più popolari per fornire accesso alle reti interne è tramite una connessione VPN. A seconda del tuo caso d'uso e della quantità di utenti che necessitano di accedere al tuo nodo, una connessione VPN potrebbe essere un'opzione. [OpenVPN](https://openvpn.net/) è una VPN SSL completa che implementa l'estensione di rete sicura di livello 2 o 3 OSI, utilizzando il protocollo standard SSL/TLS, supporta metodi di autenticazione flessibili del client basati su certificati, smart card e/o credenziali nome utente/password e consente politiche di controllo dell'accesso specifiche per utente o gruppo utilizzando le regole del firewall applicate all'interfaccia virtuale della VPN. +Infine, uno dei metodi più popolari per fornire accesso alle reti interne è tramite una connessione VPN. A seconda del tuo caso d'uso e della quantità di utenti che devono poter accedere al tuo nodo, una connessione VPN potrebbe essere un'opzione. [OpenVPN](https://openvpn.net/) è una VPN SSL completa che implementa l'estensione di rete sicura di livello 2 o 3 OSI, utilizzando il protocollo standard SSL/TLS, supporta metodi di autenticazione flessibili del client basati su certificati, smart card e/o credenziali nome utente/password e consente politiche di controllo dell'accesso specifiche per utente o gruppo utilizzando le regole del firewall applicate all'interfaccia virtuale della VPN. ### Gestire il nodo {#operating-the-node} @@ -425,7 +421,7 @@ Il tuo nodo non deve necessariamente essere sempre online, ma dovresti mantenerl - Gli arresti forzati possono danneggiare il database, obbligandoti a sincronizzare nuovamente l'intero nodo. - Il tuo client perderà la sincronizzazione con la rete e dovrà risincronizzarsi al riavvio. Sebbene il nodo possa iniziare la sincronizzazione da dove si trovava all'ultimo arresto, il processo può richiedere tempo a seconda di quanto è stato offline. -_Ciò non si applica ai nodi del validatore del livello di consenso._ Mettere offline il tuo nodo influenzerà tutti i servizi che ne dipendono. Se stai eseguendo un nodo per scopi di _staking_, dovresti cercare di ridurre al minimo i tempi di fermo. +_Ciò non si applica ai nodi del validatore del livello di consenso._ Mettere offline il tuo nodo influenzerà tutti i servizi che ne dipendono. Se stai eseguendo un nodo per scopi di _staking_, dovresti cercare di ridurre al minimo i tempi di inattività. #### Creare i servizi del client {#creating-client-services} @@ -439,15 +435,15 @@ Devi mantenere aggiornato il software del tuo client con le patch di sicurezza, Aggiornare i client è molto semplice. Ogni client ha istruzioni specifiche nella propria documentazione, ma il processo consiste generalmente solo nello scaricare l'ultima versione e riavviare il client con il nuovo eseguibile. Il client dovrebbe riprendere da dove si è fermato, ma con gli aggiornamenti applicati. -Ogni implementazione del client ha una stringa di versione leggibile dall'uomo, utilizzata nel protocollo peer-to-peer, ma è anche accessibile dalla riga di comando. Questa stringa di versione consente agli utenti di verificare che sia in esecuzione la versione corretta e consente ai block explorer e ad altri strumenti analitici interessati di quantificare la distribuzione di client specifici sulla rete. Si rimanda alla documentazione del singolo client per maggiori informazioni sulle stringhe di versione. +Ogni implementazione del client ha una stringa di versione leggibile dall'uomo usata nel protocollo in pari, ma è anche accessibile dalla riga di comando. Questa stringa di versione consente agli utenti di verificare che sia in esecuzione la versione corretta e consente ai block explorer e ad altri strumenti analitici interessati di quantificare la distribuzione di client specifici sulla rete. Si rimanda alla documentazione del singolo client per maggiori informazioni sulle stringhe di versione. #### Eseguire servizi aggiuntivi {#running-additional-services} -Eseguire il tuo nodo ti consente di usare servizi che richiedono l'accesso diretto all'RPC del client di Ethereum. Questi sono servizi basati su Ethereum, come le [soluzioni di livello 2](/developers/docs/scaling/#layer-2-scaling), backend per i portafogli, block explorer, strumenti per gli sviluppatori e altre infrastrutture di Ethereum. +Eseguire il tuo nodo ti consente di usare servizi che richiedono l'accesso diretto all'RPC del client di Ethereum. Questi sono servizi basati su Etherreum, come le [soluzioni di livello 2](/developers/docs/scaling/#layer-2-scaling), backend per i portafogli, block explorer, strumenti per gli sviluppatori e altre infrastrutture di Ethereum. #### Monitorare il nodo {#monitoring-the-node} -Per monitorare correttamente il tuo nodo, valuta di raccogliere delle metriche. I client forniscono endpoint delle metriche, così che tu possa ottenere dati completi sul tuo nodo. Usa strumenti come [InfluxDB](https://www.influxdata.com/get-influxdb/) o [Prometheus](https://prometheus.io/) per creare database che puoi trasformare in visualizzazioni e grafici nel software, come [Grafana](https://grafana.com/). Esistono molte configurazioni per utilizzare questo software e diversi pannelli di controllo di Grafana con cui puoi visualizzare il tuo nodo e la rete per intero. Ad esempio, dai un'occhiata al [tutorial sul monitoraggio di Geth](/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/). +Per monitorare correttamente il tuo nodo, valuta di raccogliere delle metriche. I client forniscono endpoint delle metriche, così che tu possa ottenere dati completi sul tuo nodo. Usa strumenti come [InfluxDB](https://www.influxdata.com/get-influxdb/) o [Prometheus](https://prometheus.io/) per creare database che puoi trasformare in visualizzazioni e grafici nel software come [Grafana](https://grafana.com/). Esistono molte configurazioni per utilizzare questo software e diversi pannelli di controllo di Grafana con cui puoi visualizzare il tuo nodo e la rete per intero. Ad esempio, dai un'occhiata al [tutorial sul monitoraggio di Geth](/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/). Nell'ambito del monitoraggio, assicurati di tenere d'occhio le prestazioni della tua macchina. Durante la sincronizzazione iniziale del tuo nodo, il software del client potrebbe gravare molto su CPU e RAM. Oltre a Grafana, per farlo puoi usare gli strumenti che offre il tuo OS, come `htop` o `uptime`. @@ -456,7 +452,6 @@ Nell'ambito del monitoraggio, assicurati di tenere d'occhio le prestazioni della - [Guide allo staking di Ethereum](https://github.com/SomerEsat/ethereum-staking-guides) - _Somer Esat, aggiornato spesso_ - [Guida | Come configurare un validatore per lo staking di Ethereum sulla Rete Principale](https://www.coincashew.com/coins/overview-eth/guide-or-how-to-setup-a-validator-on-eth2-mainnet) _– CoinCashew, aggiornato regolarmente_ - [Guide di ETHStaker all'esecuzione dei validatori sulle reti di prova](https://github.com/remyroy/ethstaker#guides) – _ETHStaker, aggiornato regolarmente_ -- [Guide allo staking di Ethereum](https://github.com/SomerEsat/ethereum-staking-guides) _– Somer Esat, aggiornato regolarmente_ - [Domande frequenti sulla Fusione per gli operatori di nodi](https://notes.ethereum.org/@launchpad/node-faq-merge) - _Luglio 2022_ - [Analizzare i requisiti hardware per essere un nodo completo e validato di Ethereum](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _– Albert Palau, 24 settembre 2018_ - [Eseguire i nodi completi di Ethereum: una guida per i poco motivati](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 novembre 2019_ @@ -465,6 +460,6 @@ Nell'ambito del monitoraggio, assicurati di tenere d'occhio le prestazioni della ## Argomenti correlati {#related-topics} -- [Nodi e client](/developers/docs/nodes-and-clients/) +- [ Nodi e client](/developers/docs/nodes-and-clients/) - [Blocchi](/developers/docs/blocks/) - [Reti](/developers/docs/networks/) diff --git a/src/content/translations/it/developers/docs/programming-languages/python/index.md b/src/content/translations/it/developers/docs/programming-languages/python/index.md index 6a3bb445e64..6c82a435f80 100644 --- a/src/content/translations/it/developers/docs/programming-languages/python/index.md +++ b/src/content/translations/it/developers/docs/programming-languages/python/index.md @@ -23,11 +23,12 @@ Hai prima bisogno di nozioni di base? Dai un'occhiata a [ethereum.org/learn](/le ## Articoli per chi inizia ora {#beginner-articles} - [Guida di uno sviluppatore (Python) a Ethereum](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/) -- [Un'Introduzione ai Contratti Intelligenti con Vyper](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/) +- [Report 2023 sullo stato di Python in blockchain](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023) +- [Introduzione agli Smart Contract con Vyper (in inglese)](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/) - [Distribuisci il tuo Token ERC20 con Python e Brownie](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58) -- [Come sviluppare un contratto Ethereum utilizzando Python Flask?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e) -- [Introduziona Web3.py · Ethereum per sviluppatori Python](https://www.dappuniversity.com/articles/web3-py-intro) -- [Come chiamare la funzione di un Contratto Intelligente usando Python e web3.py](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py) +- [Come sviluppare un contratto Ethereum usando Python Flask (in inglese)](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e) +- [Introduzione a Web3.py · Ethereum per sviluppatori Python (in inglese)](https://www.dappuniversity.com/articles/web3-py-intro) +- [Come chiamare la funzione di uno Smart Contract usando Python e web3.py (in inglese)](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py) ## Articoli di livello intermedio {#intermediate-articles} @@ -64,7 +65,7 @@ Hai prima bisogno di nozioni di base? Dai un'occhiata a [ethereum.org/learn](/le ### Archiviato / Non più mantenuto: {#archived--no-longer-maintained} - [Trinity](https://github.com/ethereum/trinity) - _Il client Python di Ethereum_ -- [Mamba](https://mamba.black) - _Framework per scrivere, compilare e distribuire contratti intelligenti scritti nel linguaggio Vyper_ +- [Mamba](https://github.com/arjunaskykok/mamba) - _Framework per scrivere, compilare e distribuire contratti intelligenti scritti nel linguaggio Vyper_ Cerchi altre risorse? Dai un'occhiata a [ethereum.org/developers](/developers/). diff --git a/src/content/translations/it/developers/docs/programming-languages/rust/index.md b/src/content/translations/it/developers/docs/programming-languages/rust/index.md index 5fe7fd57216..ab9528e1ca2 100644 --- a/src/content/translations/it/developers/docs/programming-languages/rust/index.md +++ b/src/content/translations/it/developers/docs/programming-languages/rust/index.md @@ -26,34 +26,32 @@ Hai prima bisogno di nozioni di base? Dai un'occhiata a [ethereum.org/learn](/le - [The Rust Ethereum Client](https://openethereum.github.io/) \* **Notare che OpenEthereum [è ormai superato](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) e non viene più mantenuto.** Usalo con cautela e preferibilmente passa a un'altra implementazione client. - [Sending Transaction to Ethereum Using Rust](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/) - [Un'Introduzione ai Contratti Intelligenti con il Client di Ethereum Parity](https://wiki.parity.io/Smart-Contracts) -- [Setting up your Oasis SDK dev environment](https://docs.oasis.dev/oasis-sdk/guide/getting-started) -- [A step-by-step tutorial on how to write contracts in rust Wasm for Kovan](https://github.com/paritytech/pwasm-tutorial) +- [Una guida passo-passo su come scrivere un contratto in rust Wasm per Kovan](https://github.com/paritytech/pwasm-tutorial) ## Articoli di livello intermedio {#intermediate-articles} ## Modelli d'uso avanzati {#advanced-use-patterns} -- [pwasm_ethereum externs library to interact with Ethereum-like network](https://github.com/openethereum/pwasm-ethereum) -- [Build A Decentralized Chat Using JavaScript and Rust](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52) -- [Build a Decentralized Todo App Using Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb) -- [Getting Started with Enigma - In Rust Programming Language](https://blog.enigma.co/getting-started-with-discovery-the-rust-programming-language-4d1e0b06de15) -- [An Intro to Secret Contracts](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) -- [Deploying Solidity Contracts on Oasis (Compound)](https://docs.oasis.dev/tutorials/deploy-solidity.html#deploy-using-truffle) -- [Crea una blockchain in Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) +- [Libreria pwasm_ethereum esterna per interagire con reti di tipo Ethereum (in inglese)](https://github.com/openethereum/pwasm-ethereum) +- [Creare una chat decentralizzata usando JavaScript e Rust (in inglese)](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52) +- [Creare un'app decentralizzata Todo usando Vue.js e Rust (in inglese)](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb) + +- [Introduzione ai contratti segreti (in inglese)](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) +- [Costruisci una blockchain in Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) ## Progetti e strumenti di Rust {#rust-projects-and-tools} -- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _Raccolta di risorse esterne per interagire con una rete di tipo Ethereum_ +- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _Raccolta di esterni per interagire con reti simili a Ethereum_ - [Lighthouse](https://github.com/sigp/lighthouse) - _Client veloce del livello di consenso di Ethereum_ -- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) +- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _Rivisitazione proposta del livello di esecuzione del contratto intelligente di Ethereum, utilizzando un sottoinsieme deterministico di WebAssembly_ - [oasis_std](https://docs.rs/oasis-std/0.2.7/oasis_std/) - _Riferimento API di OASIS_ -- [Solaris](https://github.com/paritytech/sol-rs) -- [SputnikVM](https://github.com/sorpaas/rust-evm) - _Implementazione della macchina virtuale Ethereum in Rust_ -- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contratto intelligente Wavelet su Rust_ +- [Solaris](https://github.com/paritytech/sol-rs) - _Test unitario dei contratti intelligenti in Solidity che sfrutta l'utilizzo dell'EVM nativa del Client di Parity._ +- [SputnikVM](https://github.com/rust-blockchain/evm) - _Implementazione della Macchina Virtuale di Ethereum in Rust_ +- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Smart Contract Wavelet in Rust_ - [Foundry](https://github.com/gakonst/foundry)- _Toolkit per lo sviluppo di applicazioni Ethereum_ -- [Ethers_rs](https://github.com/gakonst/ethers-rs)- _Libreria di Ethereum e implementazione di portafogli_ -- [evm_rs](https://github.com/rust-blockchain/evm)- _Implementazione della macchina virtuale di Ethereum in Rust_ +- [Ethers_rs](https://github.com/gakonst/ethers-rs)- _Implementazione di librerie e portafogli di Ethereum_ - [SewUp](https://github.com/second-state/SewUp) - _Una libreria per aiutarti a creare il tuo contratto webassembly di Ethereum con Rust e sviluppare in un backend comune_ +- [Reth](https://github.com/paradigmxyz/reth) Reth (abbreviazione di Rust Ethereum, pronuncia) è una nuova implementazione a nodo completo su Ethereum Cerchi altre risorse? Dai un'occhiata a [ethereum.org/developers.](/developers/) diff --git a/src/content/translations/it/developers/docs/storage/index.md b/src/content/translations/it/developers/docs/storage/index.md index 33ae39501e0..fb6351ad3ae 100644 --- a/src/content/translations/it/developers/docs/storage/index.md +++ b/src/content/translations/it/developers/docs/storage/index.md @@ -47,6 +47,8 @@ Le piattaforme con persistenza basata su contratto sono: - [Storj](https://storj.io/) - [0Chain](https://0chain.net/) - [Rete Crust](https://crust.network) +- [Swarm](https://www.ethswarm.org/) +- [4EVERLAND](https://www.4everland.org/) ### Considerazioni aggiuntive {#additional-consideration} @@ -57,14 +59,18 @@ IPFS è un sistema distribuito per memorizzare e accedere a file, siti web, appl - [Pinata](https://www.pinata.cloud/) _(servizio di pinning IPFS)_ - [Pinata](https://www.pinata.cloud/) _(servizio di pinning IPFS)_ - [IPFS Scan](https://ipfs-scan.io) _(esploratore di pinning di IPFS)_ +- [4EVERLAND](https://www.4everland.org/)_（Servizio di pinning IPFS）_ +- [Filebase](https://filebase.com) _(Servizio di pinning IPFS)_ + +SWARM è una tecnologia decentralizzata di archiviazione e distribuzione di dati con un sistema di incentivazione di archiviazione e un oracolo del prezzo di affitto della memoria. ## Ritenzione dei dati {#data-retention} -Per ritenere i dati, i sistemi devono avere qualche tipo di meccanismo per assicurarsi che i dati vengano conservati. +Per conservare i dati, i sistemi devono avere qualche tipo di meccanismo per assicurarsi che i dati vengano conservati. ### Meccanismo di messa alla prova {#challenge-mechanism} -Per verificare l'effettiva conservazione dei dati, uno dei metodi più diffusi consiste nell'utilizzare un meccanismo di messa alla prova crittografica emessa ai nodi per accertare che contengano ancora i dati. Un esempio semplice è quello del Proof of Access di Arweave. I nodi vengono messi alla prova per vedere se contengono i dati sia sul blocco più recente sia su un blocco passato a caso. Se il nodo non trova la risposta, viene penalizzato. +Uno dei metodi più diffusi per verificare l'effettiva conservazione dei dati consiste nell'utilizzare qualche tipo di meccanismo di messa alla prova crittografica applicato ai nodi per accertare che contengano ancora i dati. Un esempio semplice è quello di verificare il proof-of-access di Arweave. I nodi vengono messi alla prova per vedere se contengono i dati sia sul blocco più recente sia su un blocco casuale in passato. Se il nodo non trova la risposta, viene penalizzato. Tipi di dStorage con meccanismo di messa alla prova: @@ -73,10 +79,11 @@ Tipi di dStorage con meccanismo di messa alla prova: - Arweave - Filecoin - Rete Crust +- 4EVERLAND ### Decentralità {#decentrality} -Non esistono strumenti impeccabili per misurare il livello di decentralizzazione delle piattaforme ma, in generale, si tende a ricorrere a strumenti che non utilizzano un tipo di KYC per dimostrare di non essere centralizzati. +Non esistono strumenti impeccabili per misurare il livello di decentralizzazione delle piattaforme ma, in generale, si tende a ricorrere a strumenti che non utilizzano qualche tipo di KYC per dimostrare di non essere centralizzati. Strumenti decentralizzati senza KYC: @@ -87,10 +94,11 @@ Strumenti decentralizzati senza KYC: - IPFS - Ethereum - Rete Crust +- 4EVERLAND ### Consenso {#consensus} -Gran parte di questi strumenti ha la propria versione di un [meccanismo di consenso](/developers/docs/consensus-mechanisms/) ma, generalmente, si basano su [**Proof of Work (PoW)**](/developers/docs/consensus-mechanisms/pow/) o [**Proof of Stake (PoS)**](/developers/docs/consensus-mechanisms/pos/). +Gran parte di questi strumenti ha la propria versione di un [meccanismo di consenso](/developers/docs/consensus-mechanisms/), ma generalmente si basano su [**proof-of-work (PoW)**](/developers/docs/consensus-mechanisms/pow/) o [**proof-of-stake (PoS)**](/developers/docs/consensus-mechanisms/pos/). Basata sul proof-of-work: @@ -106,7 +114,7 @@ Basata sul proof-of-stake: ## Strumenti correlati {#related-tools} -**IPFS - _InterPlanetary File System è un sistema di archiviazione decentralizzata e referenziazione dei file per Ethereum._** +**IPFS - _InterPlanetary File System è un sistema decentralizzato di archiviazione e referenziazione dei file per Ethereum._** - [Ipfs.io](https://ipfs.io/) - [Documentazione](https://docs.ipfs.io/) @@ -116,6 +124,7 @@ Basata sul proof-of-stake: - [Storj.io](https://storj.io/) - [Documentazione](https://docs.storj.io/) +- [GitHub](https://github.com/storj/storj) **Skynet - _Skynet è una catena di PoW decentralizzata dedicata a un web decentralizzato._** @@ -135,7 +144,7 @@ Basata sul proof-of-stake: - [Documentazione](https://docs.arweave.org/info/) - [Arweave](https://github.com/ArweaveTeam/arweave/) -**0chain - _0Chain è una piattaforma di dStorage in Proof of Stake con sharding e blobber._** +**0chain - _0Chain è una piattaforma di dStorage in proof-of-stake con sharding e blobber._** - [0Chain.net](https://0chain.net/) - [Documentazione](https://docs.0chain.net/0chain/) @@ -159,7 +168,7 @@ Basata sul proof-of-stake: - [Documentazione](https://github.com/orbitdb/field-manual/) - [GitHub](https://github.com/orbitdb/orbit-db/) -**Aleph.im - _Progetto su cloud decentralizzato (database, archiviazione di file, calcolo e DID). Una combinazione unica di tecnologia peer-to-peer on-chain e off-chain. Compatibilità multi-catena e IPFS._** +**Aleph.im - _Progetto decentralizzato su cloud (database, archiviazione di file, calcolo e DID). Una combinazione unica di tecnologia peer-to-peer on-chain e off-chain. Compatibilità multi-catena e IPFS._** - [Aleph.im](https://aleph.im/) - [Documentazione](https://aleph.im/#/developers/) @@ -171,19 +180,31 @@ Basata sul proof-of-stake: - [Documentazione](https://developers.ceramic.network/learn/welcome/) - [GitHub](https://github.com/ceramicnetwork/js-ceramic/) -**Filebase - _La prima piattaforma di archiviazione di oggetti compatibile con S3 che consente di archiviare i dati su più reti d'archiviazione decentralizzata, tra cui IPFS, Sia, Skynet e Storj._** +**Filebase - _archiviazione decentralizzata compatibile con S3 e servizio di pinning IPFS geo-ridondante. Tutti i file caricati in IPFS tramite Filebase sono fissati automaticamente all'infrastruttura di Filebase con replicazione 3x in tutto il globo._** - [Filebase.com](https://filebase.com/) - [Documentazione](https://docs.filebase.com/) - [GitHub](https://github.com/filebase) +**4EVERLAND: _Una piattaforma di cloud computing in Web 3.0 che integra archiviazione, calcolo e capacità essenziali di rete, è compatibile con S3 e fornisce l'archiviazione sincrona dei dati su reti di archiviazione decentralizzate quali IPFS e Arweave._** + +- [4everland.org](https://www.4everland.org/) +- [Documentazione](https://docs.4everland.org/) +- [GitHub](https://github.com/4everland) + +**Kaleido - _Una piattaforma di blockchain-as-a-service con Nodi IPFS alla pressione di un pulsante_** + +- [Kaleido](https://kaleido.io/) +- [Documentazione](https://docs.kaleido.io/kaleido-services/ipfs/) +- [GitHub](https://github.com/kaleido-io) + ## Letture consigliate {#further-reading} - [Cos'è l'archiviazione decentralizzata?](https://coinmarketcap.com/alexandria/article/what-is-decentralized-storage-a-deep-dive-by-filecoin) - _CoinMarketCap_ - [Sfatiamo cinque falsi miti sull'archiviazione decentralizzata](https://www.storj.io/blog/busting-five-common-myths-about-decentralized-storage) - _Storj_ -_Conosci una risorsa della community che ti è stata utile? Modifica questa pagina e aggiungila!_ +_Conosci una risorsa pubblica che ti è stata utile? Modifica questa pagina e aggiungila!_ ## Argomenti correlati {#related-topics} -- [Framework di sviluppo](/developers/docs/frameworks/) +- [Quadri di sviluppo](/developers/docs/frameworks/) diff --git a/src/content/translations/it/energy-consumption/energy_consumption_pre_post_merge.png b/src/content/translations/it/energy-consumption/energy_consumption_pre_post_merge.png new file mode 100644 index 00000000000..3eb7f338a13 Binary files /dev/null and b/src/content/translations/it/energy-consumption/energy_consumption_pre_post_merge.png differ diff --git a/src/content/translations/it/energy-consumption/index.md b/src/content/translations/it/energy-consumption/index.md index bdf7ce2797d..ea525d02119 100644 --- a/src/content/translations/it/energy-consumption/index.md +++ b/src/content/translations/it/energy-consumption/index.md @@ -1,75 +1,80 @@ --- -title: Consumo energetico di Ethereum +title: Spesa energetica di Ethereum description: Le informazioni di base necessarie per capire il consumo energetico di Ethereum. lang: it --- -# Consumo energetico di Ethereum {#introduction} +# Il consumo energetico di Ethereum {#proof-of-stake-energy} -Ethereum è una blockchain ecologica. Usa un meccanismo di consenso di [proof-of-stake](/developers/docs/consensus-mechanisms/pos) che può esser eseguito sui dispositivi a bassa potenza e non richiede elevata potenza di calcolo per partecipare. Il meccanismo di proof-of-stake di Ethereum protegge la rete usando gli ETH in staking piuttosto che l'energia consumata, come nel [proof-of-work](/developers/docs/consensus-mechanisms/pow). Il passaggio al proof-of-stake significa che l'energia consumata dalla rete di Ethereum è relativamente ridotta, verso i 0,01 TWh/anno. +Ethereum è una blockchain ecologica. Il meccanismo di consenso di [proof-of-stake](/developers/docs/consensus-mechanisms/pos) di Ethereum utilizza gli ETH invece dell'[energia, per proteggere la rete](/developers/docs/consensus-mechanisms/pow). Il consumo energetico di Ethereum è approssimativamente pari a [0,0026 TWh/anno](https://carbon-ratings.com/eth-report-2022), sull'intera rete globale. -## Spesa energetica del proof-of-stake {#proof-of-stake-energy} +La stima del consumo energetico per Ethereum proviene da uno studio del [CCRI (Istituto di Valutazione Carbonica Cripto)](https://carbon-ratings.com). Hanno generato stime dettagliate del consumo energetico e dell'impronta carbonica della rete di Ethereum ([vedi lo studio](https://carbon-ratings.com/eth-report-2022)). I membri del CCRI hanno misurato il consumo di energia elettrica di diversi nodi con varie configurazioni hardware e software del client. Il consumo energetico annuale stimato della rete di **2.601 MWh** (0,0026 TWh), corrisponde alle emissioni carboniche annuali di **870 tonnellate di CO2e**, applicando i fattori di intensità carbonica specifici a livello regionale. Questo valore cambia quando i nodi accedono a e abbandonano la rete: è possibile tenerne traccia utilizzando una stima media di 7 giorni, dall'[Indice di Sostenibilità delle Reti Blockchain di Cambridge](https://ccaf.io/cbnsi/ethereum) (utilizzano un metodo lievemente differente per le loro stime, i dettagli sono disponibili sul loro sito). -Il consumo energetico di Ethereum è approssimativamente pari al costo di operazione di un portatile modesto per ogni nodo sulla rete. +Per contestualizzare il consumo energetico di Ethereum, confrontiamo le stime annualizzate per alcuni altri settori. Ciò ci aiuta a meglio comprendere se la stima per Ethereum sia alta o bassa. -Molti articoli stimano una spesa energetica "per transazione" per confrontare le blockchain ad altre industrie. Il beneficio di ciò è che è facile da comprendere. Tuttavia, le stime basate sulle transazioni possono essere fuorvianti poiché l'energia richiesta per proporre e validare un blocco è indipendente dal numero di transazioni al suo interno. Un'unità di spesa energetica per transazione implica che meno transazioni porterebbero a una spesa minore e viceversa, il che non è vero. Una stima per transazione dipende fortemente da come è definito il volume di transazione di una blockchain e, modificare tale definizione, può far sembrare maggiore o minore il valore. - -Ad esempio, su Ethereum, il volume di transazione non è solo quello del livello di base, è anche la somma del volume di transazione di tutti i suoi rollup del "[livello 2](/layer-2/)", non generalmente inclusi nei calcoli e che lo ridurrebbero drasticamente. Questo è uno dei motivi per cui gli strumenti che confrontano il consumo energetico per transazione sulle piattaforme, sono fuorvianti. + -Più rilevante è il consumo energetico complessivo e l'impronta carbonica dell'intera rete. Da tali valori, possiamo esaminare ciò che la rete offre ai suoi utenti e alla società intera ed effettuare una valutazione più globale del fatto che la spesa energetica sia o meno giustificata. Le misurazioni per transazione, d'altra parte, implicano che il valore della rete provenga solo dal suo ruolo nel trasferire criptovalute tra conti e proibiscono un'analisi onesta di costi e benefici. +Il grafico precedente mostra il consumo energetico annuale stimato in TWh/anno per Ethereum, rispetto a svariate altre industrie. Le stime fornite provengono da informazioni disponibili pubblicamente (ultimo accesso a maggio 2023), con collegamenti alle fonti disponibili nella seguente tabella: -Il [CCRI](https://carbon-ratings.com) (Crypto Carbon Ratings Institute) ha analizzato ampiamente il consumo di elettricità e l'impronta carbonica della rete Ethereum (vedi il report [_La Fusione - Implicazioni sul consumo elettrico e sull'impronta carbonica della rete Ethereum_](https://carbon-ratings.com/eth-report-2022)). Il CCRI ha misurato il consumo elettrico di diversi nodi con varie configurazioni hardware e software del client. Ne è risultata una stima di **2,601 MWh** (0,0026 TWh) per il consumo annuo di elettricità della rete al momento dell'analisi (settembre 2022), corrispondente alle emissioni carboniche annuali di **870 tonnellate di CO2e**, applicando i fattori di intensità carbonica specifici regionali. +| | Consumo energetico annuo (TWh) | Confronto con Ethereum PoS | Fonte | +| :------------------------------- | :----------------------------: | :------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Centri elaborazione dati globali | 200 | 77,000x | [fonte](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches) | +| Estrazione dell'oro | 131 | 50,000x | [fonte](https://ccaf.io/cbnsi/cbeci/comparisons) | +| Bitcoin | 131 | 50,000x | [fonte](https://ccaf.io/cbnsi/cbeci/comparisons) | +| Ethereum PoW | 78 | 30,000x | [fonte](https://digiconomist.net/ethereum-energy-consumption) | +| Youtube (solo diretto) | 12 | 4600x | [fonte](https://www.gstatic.com/gumdrop/sustainability/google-2020-environmental-report.pdf) | +| Videogiochi negli Stati Uniti | 34 | 13.000x | [fonte](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential) | +| Netflix | 0,451 | 173x | [fonte](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) | +| PayPal | 0,26 | 100x | [fonte](https://app.impaakt.com/analyses/paypal-consumed-264100-mwh-of-energy-in-2020-24-from-non-renewable-sources-27261) | +| AirBnB | 0,02 | 8x | [fonte]() | +| Ethereum PoS | 0,0026 | 1x | [fonte](https://carbon-ratings.com/eth-report-2022) | -[Digiconomist fornisce il consumo energetico e le impronte carboniche dell'intera rete per Bitcoin ed Ethereum](https://digiconomist.net/ethereum-energy-consumption). Nel momento in cui viene scritto questo articolo, Bitcoin consuma circa 200 TWh/anno di energia ed emette circa 100 MT (megatonnellate) di carbonio all'anno, generando circa 32.000 t di rifiuti energetici da hardware obsoleti ogni anno. In confronto, la spesa energetica totale per proteggere Ethereum è più vicina a **0,01 TWh/anno**. +È complicato ottenere stime accurate per il consumo energetico, specialmente quando ciò che viene misurato ha una catena di fornitura complessa o dettagli di distribuzione che ne influenzano l'efficienza. Considera Netflix o YouTube come esempi. Le stime del loro consumo energetico variano a seconda del fatto che includano esclusivamente l'energia utilizzata per mantenere i loro sistemi e fornire contenuti agli utenti (_consumo diretto_) o includano il consumo necessario a produrre i contenuti, gestire gli uffici operativi, pubblicizzare, ecc. (_consumo indiretto_). L'utilizzo indiretto potrebbe anche includere l'energia necessaria per consumare i contenuti sui dispositivi dell'utente finale, quali TV, computer e dispositivi mobili, che a loro volta dipendono dai dispositivi utilizzati. - +Esiste una discussione su questo problema su [Carbon Brief](https://www.carbonbrief.org/factcheck-what-is-the-carbon-footprint-of-streaming-video-on-netflix). Nella tabella precedente, il valore riportato per Netflix include i loro utilizzi _diretti_ e _indiretti_ auto-segnalati. YouTube fornisce soltanto una stima del proprio consumo _diretto_, pari a circa [12 TWh/anno](https://www.gstatic.com/gumdrop/sustainability/google-2020-environmental-report.pdf). -La suddetta cifra mostra il consumo energetico annuale stimato in TWh/anno per vari settori (aggiornata a giugno 2022). _Nota che le stime presentate nel grafico provengono da fonti disponibili pubblicamente, delle quali si riporta il link nel testo di seguito. Sono illustrative e non rappresentano una stima, promessa o previsione ufficiale._ +La tabella e il grafico precedenti, inoltre, includono confronti con Bitcoin e l'Ethereum di proof-of-work. È importante notare che il consumo energetico delle reti di proof-of-work non è statico ma cambia quotidianamente. Il valore utilizzato per Ethereum proof-of-work proviene da poco prima della [Fusione](/roadmap/merge/) al proof-of-stake, come previsto da [Digiconomist](https://digiconomist.net/ethereum-energy-consumption). Altre fonti, come l'[Indice di Sostenibilità delle Reti Blockchain di Cambridge](https://ccaf.io/cbnsi/ethereum/1), stimano il consumo energetico come molto inferiore (più vicino a 20 TWh/anno). Anche le stime per i consumi energetici di Bitcoin variano ampiamente a seconda delle fonti, ed è un argomento che attira molti [dibattiti](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/) articolati, non soltanto sulla quantità di energia consumata, ma anche sulle fonti di tale energia e la correlata etica. Il consumo energetico non è per forza associato all'impronta ambientale, poiché progetti differenti potrebbero utilizzare fonti energetiche diverse, ad esempio una percentuale maggiore o minore di rinnovabili. Ad esempio, l'[Indice di Consumo Energetico di Bitcoin di Cambridge](https://ccaf.io/cbnsi/cbeci/comparisons), indica che la domanda della rete di Bitcoin potrebbe essere teoricamente alimentata da gas o elettricità che andrebbero altrimenti persi in trasmissione e distribuzione. Il percorso di Ethereum verso la sostenibilità è stato quello di sostituire la parte ad alto consumo energetico della rete, con un'alternativa ecosostenibile. -Per contestualizzare il consumo energetico di Ethereum, possiamo confrontare le stime annualizzate per altri settori. Se consideriamo Ethereum una piattaforma per mantenere in modo sicuro gli asset digitali come investimenti, forse possiamo compararla all'estrazione dell'oro, che si stima consumi circa [240 TWh/anno](https://www.kitco.com/news/2021-05-17/Gold-s-energy-consumption-doubles-that-of-bitcoin-Galaxy-Digital.html). Come piattaforma di pagamenti digitali, potremmo forse compararla a PayPal (che si stima consumi circa [0,26 TWh/anno](https://app.impaakt.com/analyses/paypal-consumed-264100-mwh-of-energy-in-2020-24-from-non-renewable-sources-27261)). Come piattaforma di intrattenimento, potremmo forse compararla all'industria videoludica, che si stima consumi circa [34 TW/anno](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential) _nei soli Stati Uniti_. Le stime del consumo energetico di Netflix oscillano drasticamente tra [circa 0,45TWhr/anno](https://s22.q4cdn.com/959853165/files/doc_downloads/2020/02/0220_Netflix_EnvironmentalSocialGovernanceReport_FINAL.pdf) (come da sua stima del 2019) fino a circa 94 TWh/anno (come stimato da [Shift Project](https://theshiftproject.org/en/article/unsustainable-use-online-video/)); esistono delle discussioni sulle ipotesi sottostanti tali stime, disponibili su [Carbon Brief](https://www.carbonbrief.org/factcheck-what-is-the-carbon-footprint-of-streaming-video-on-netflix). Altrimenti, Ethereum potrebbe essere comparata a YouTube, che si stima consumi circa [244 TWh/anno](https://thefactsource.com/how-much-electricity-does-youtube-use/), sebbene questi valori dipendano molto dal tipo di dispositivo su cui sono trasmessi i video e dall'efficienza energetica dell'infrastruttura sottostante, come i centri di dati. Le stime del consumo energetico di YouTube sono state ripartite per canali e singoli video. [Queste stime](https://thefactsource.com/how-much-electricity-does-youtube-use/) lasciano intendere che le persone che hanno guardato Gangnam Style nel 2019 hanno consumato 45 volte più energia di quella utilizzata dal proof-of-stake di Ethereum in un anno. - -## Un livello d'applicazione ecologico {#green-applications} +Puoi sfogliare le stime sui consumi energetici e le emissioni carboniche per molti settori sul [sito dell'Indice di Sostenibilità delle Reti Blockchain di Cambridge](https://ccaf.io/cbnsi/ethereum). -Mentre il consumo energetico di Ethereum è molto ridotto, vi è anche una community sostanziale, in crescita e altamente attiva di **finanza rigenerativa (ReFi)** che sta nascendo su Ethereum. Le applicazioni ReFi usano i componenti della DeFi per creare applicazioni finanziarie aventi esternalità positive a beneficio dell'ambiente. La ReFi è parte di un più ampio movimento ["solarpunk"](https://en.wikipedia.org/wiki/Solarpunk), strettamente allineato con Ethereum e che mira ad accoppiare l'avanzamento tecnologico alla gestione ambientale. La natura decentralizzata, senza permessi e componibile di Ethereum lo rende il livello di base ideale per la ReFi e le community solarpunk. Tramite il loro sviluppo (e altri, es. [DeSci](/desci/)), Ethereum sta diventando una tecnologia positiva in termini ambientali e sociali. +## Stime per transazione {#per-transaction-estimates} -## Il debito carbonico di Ethereum {#carbon-debt} +Molti articoli stimano il dispendio energetico "per transazione" delle blockchain. Questo dato può essere fuorviante perché l'energia necessaria per proporre e convalidare un blocco è indipendente dal numero di transazioni al suo interno. Un'unità di spesa energetica per transazione implica che un minor numero di transazioni comporti una minore spesa energetica e viceversa, ma non è così. Inoltre, le stime per transazione sono molto sensibili al modo in cui viene definita la portata di trasmissione delle transazioni di una blockchain, e la modifica di questa definizione può essere manipolata per far sembrare il valore maggiore o minore. -Il consumo energetico corrente di Ethereum è molto ridotto, ma non è sempre stato così. Ethereum è passato al suo meccanismo di consenso di proof-of-stake nel 3° trimestre del 2022. Tuttavia, dal 2014 al 2022 Ethereum ha usato un meccanismo di proof-of-work, che ha avuto un costo ambientale molto maggiore. +Ad esempio, su Ethereum, la portata di trasmissione delle transazioni non è solo quella del livello base, ma è anche la somma delle portate di trasmissione delle transazioni di tutti i relativi rollup di "[livello 2](/layer-2/)". I livelli 2 non sono generalmente inclusi nei calcoli, ma è probabile che tenere conto dell'energia aggiuntiva consumata dai sequenziatori (poca) e del numero di transazioni che elaborano (molte) contribuirebbe a una riduzione drastica delle stime per transazione. Questo è uno dei motivi per cui il confronto del consumo energetico per transazione tra le varie piattaforme può essere fuorviante. -Dalle sue origini, Ethereum ha mirato a implementare un meccanismo di consenso di proof-of-stake, ma farlo senza sacrificare la sicurezza e la decentralizzazione ha richiesto anni di ricerca e sviluppo mirati. Dunque, per avviare la rete è stato usato un meccanismo di proof-of-work. Il consenso di proof-of-work richiede ai miner di usare il proprio hardware per risolvere un rompicapo, consumando energia nel processo. La soluzione al rompicapo prova che l'energia è stata realmente utilizzata dal miner, dimostrando che ha investito valore del mondo reale per il diritto ad aggiungere elementi alla blockchain. Il consumo energetico totale di Ethereum ha raggiunto un picco durante l'apice del mercato rialzista delle criptovalute a febbraio 2022 a poco meno di 94 TWh/anno. Nell'estate precedente al passaggio al proof-of-stake, il consumo energetico era più vicino ai 60 TWh/anno, comparabile a quello dell'Uzbekistan, con un'emissione carbonica equivalente a quella dell'Azerbaijan (33 MT/anno). +## Il debito di carbonio di Ethereum {#carbon-debt} -Il [CCRI](https://carbon-ratings.com) ha esaminato l'impatto della fusione di Ethereum dal proof-of-work al proof-of-stake; i risultati hanno sottolineato il significativo impatto del cambiamento del protocollo di consenso: il consumo di elettricità annualizzato è stato ridotto da 22.900.320 MWh a 2.601 MWh e, dunque, di oltre il **99,988%**. Similmente, l'impronta carbonica di Ethereum è stata ridotta approssimativamente del **99,992%** (da 11.016.000 a 870 tonnellate di CO2e). Rappresentato metaforicamente, ciò corrisponde a una riduzione delle emissioni dall'altezza della Torre Eiffel a un piccolo giocattolo di plastica, come mostrato nella figura sottostante. +Il dispendio energetico di Ethereum è molto basso, ma non è sempre stato così. Originariamente Ethereum utilizzava la proof-of-work, che aveva un costo ambientale molto più elevato dell'attuale meccanismo proof-of-stake. -![Confronto del consumo energetico di Ethereum prima e dopo La Fusione. Sulla sinistra è mostrata la Torre Eiffel, alta 330 metri, e sulla destra un giocattolo di plastica, alto 4 cm, sotto una lente d'ingrandimento.](energy_consumption_pre_post_merge.png) +Fin dall'inizio, Ethereum ha pianificato d'implementare un meccanismo di consenso basato sulla proof-of-stake, ma per farlo senza sacrificare la sicurezza e la decentralizzazione sono stati necessari anni di ricerca e sviluppo mirati. Dunque, per avviare la rete è stato usato un meccanismo proof-of-work. La proof-of-work richiede che i minatori utilizzino il processore del proprio dispositivo per calcolare un valore, spendendo energia nel processo. -Sia il proof-of-work che il proof-of-stake sono semplicemente meccanismi per decidere chi aggiungerà il prossimo blocco. Passare dal proof-of-work al proof-of-stake, in cui il valore reale investito proviene dagli ETH in staking direttamente in un contratto intelligente, rimuove la necessità per i miner di consumare energia per aggiungere alla blockchain. Dunque, il costo ambientale per proteggere la rete è ridotto drasticamente. +![Confronto tra il consumo energetico di Ethereum prima della Fusione e dopo, utilizzando la Torre Eiffel (alta 330 metri) sulla sinistra per simbolizzare il consumo energetico prima della Fusione e un piccolo personaggio Lego di 4 cm sulla destra per rappresentare la drastica riduzione del consumo energetico dopo di essa](energy_consumption_pre_post_merge.png) -## Perché il proof-of-stake è più ecologico del proof-of-work? {#why-pos-is-greener-than-pow} +Il CCRI stima che La Fusione abbia ridotto il consumo energetico annualizzato di Ethereum per oltre il **99,988%**. Similmente, l'impronta di carbonio di Ethereum è stata ridotta approssimativamente del **99,992%** (da 11.016.000 a 870 tonnellate di CO2e). Per mettere tutto questo in prospettiva, la riduzione delle emissioni equivale a passare dall'altezza della Torre Eiffel a un piccolo personaggio giocattolo in plastica, come illustrato nell'immagine precedente. Di conseguenza, il costo ambientale della protezione della rete è ridotto drasticamente. Al contempo, si ritiene che la sicurezza della rete sia aumentata. -Il proof-of-work è un metodo forte per proteggere la rete. Le transazioni sulla blockchain di Ethereum sotto il precedente sistema di proof-of-work erano validate dai [miner](/developers/docs/consensus-mechanisms/pow/mining). I miner raggruppavano le transazioni in blocchi ordinati e li aggiungevano alla blockchain di Ethereum. I nuovi blocchi venivano trasmessi a tutti gli altri operatori del nodo che eseguivano le transazioni in modo indipendente e verificavano che fossero valide. Qualsiasi azione disonesta si presentava come un'incongruenza tra i diversi nodi. I blocchi onesti erano aggiunti alla blockchain e diventavano una parte immutabile dello storico. La capacità di ogni miner di aggiungere nuovi blocchi funziona solo se c'è un costo associato al mining e vi è imprevedibilità su quale nodo specifico invii il blocco successivo. Tali condizioni sono soddisfatte imponendo il proof-of-work. Per esser idoneo a inviare un blocco di transazioni, un miner deve prima inviare la soluzione di un rompicapo computazionalmente dispendioso. Per assumere correttamente il controllo della blockchain, un miner disonesto avrebbe dovuto vincere coerentemente la gara del proof-of-work investendo in hardware ed energia sufficienti a superare le prestazioni di gran parte degli altri miner. - -Questo meccanismo di protezione della rete è problematico per diversi motivi. Prima di tutto, i miner avrebbero aumentato le proprie possibilità di successo investendo in hardware più potenti, creando le condizioni per una corsa alle armi, coi miner che acquistavano equipaggiamenti di mining sempre più energivori. Questo ha aumentato il consumo energetico della rete e ha generato sprechi di hardware. In secondo luogo, il protocollo di proof-of-work di Ethereum (prima della transizione al proof-of-stake) aveva un consumo energetico annualizzato totale approssimativamente pari a quello della Finlandia [^1] e un'impronta carbonica simile a quella della Svizzera [^1]. +## Un livello d'applicazione ecologico {#green-applications} -Il proof-of-stake usa i validatori invece dei miner. I validatori ricoprono la stessa funzione dei miner, tranne che invece di consumare le proprie risorse come consumo energetico, mettono ETH in staking come garanzia contro i comportamenti disonesti. Questi ETH in staking possono essere distrutti se il validatore si comporta male, con sanzioni più severe per le azioni più nefaste. Ciò incentiva fortemente la partecipazione attiva e onesta nel proteggere la rete senza richiedere grandi consumi energetici. Poiché quasi tutta l'energia consumata proteggendo la rete di proof-of-work proveniva dall'algoritmo di mining, il passaggio al proof-of-stake ha ridotto drasticamente i consumi energetici. Inoltre, non vi è alcun beneficio nell'investire in hardware più potente sotto il proof-of-stake, quindi non esiste alcuna condizione di corsa alle armi e vi è un ridotto spreco elettronico. I validatori di Ethereum possono operare sui tipici laptop o dispositivi a basso consumo, come [Raspberry Pi](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/index.html). +Il consumo energetico di Ethereum è molto rido e al contempo su Ethereum sta crescendo una community sostanziale, in crescita e altamente attiva di **finanza rigenerativa (ReFi)**. Le applicazioni ReFi usano i componenti della DeFi per creare applicazioni finanziarie aventi esternalità positive a beneficio dell'ambiente. La ReFi è parte di un più ampio movimento ["solarpunk"](https://en.wikipedia.org/wiki/Solarpunk), strettamente allineato con Ethereum e che mira a conciliare progresso tecnologico e gestione ambientale. La natura decentralizzata, senza permessi e componibile di Ethereum lo rende il livello di base ideale per le comunità ReFi e solarpunk. -Leggi di più su [come Ethereum implementa il proof-of-stake](/developers/docs/consensus-mechanisms/pos) e com'è paragonato al proof-of-work. +Piattaforme di finanziamento di beni pubblici web3 native come [Gitcoin](https://gitcoin.co) conducono raccolte fondi climatiche per promuovere uno sviluppo consapevole dell'ambiente sul livello di applicazione di Ethereum. Grazie allo sviluppo di queste iniziative (e di altre, ad esempio [DeSci](/desci/)), Ethereum sta diventando una tecnologia positiva dal punto di vista ambientale e sociale. - Se pensi che queste statistiche siano errate o possano essere rese più accurate, ti invitiamo a segnalarlo o inviare una "Pull Request". Queste sono stime del team di ethereum.org fatte usando informazioni pubblicamente accessibili e l'attuale tabella di marcia di Ethereum. Queste dichiarazioni non rappresentano una promessa ufficiale della Fondazione Ethereum. + Se pensi che questa pagina possa essere resa più accurata, segnala un problema o una PR. Le statistiche riportate in questa pagina sono stime basate su dati pubblicamente disponibili e non rappresentano una dichiarazione o una promessa ufficiale del team di ethereum.org o della Fondazione Ethereum. -## Ulteriori letture {#further-reading} +## Letture consigliate {#further-reading} -- [L'energia necessaria a un paese; non più](https://blog.ethereum.org/2021/05/18/country-power-no-more/) – _Carl Beekhuizen, 18 maggio 2021_ -- [Consumo energetico di Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8) -- [Emissioni di Ethereum: Una Stima Completa](https://kylemcdonald.github.io/ethereum-emissions/) _Kyle McDonald_ +- [Indice di Sostenibilità delle Reti Blockchain di Cambridge](https://ccaf.io/cbnsi/ethereum) +- [Relazione della Casa Bianca sulle blockchain proof-of-work](https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf) +- [Emissioni di Ethereum: Una Stima Completa](https://kylemcdonald.github.io/ethereum-emissions/) _ Kyle McDonald_ - [Indice del Consumo Energetico di Ethereum](https://digiconomist.net/ethereum-energy-consumption/) – _Digiconomist_ - [ETHMerge.com](https://ethmerge.com/)—_[@InsideTheSim](https://twitter.com/InsideTheSim)_ - [La Fusione - Implicazioni sul consumo elettrico e sull'impronta carbonica della rete Ethereum](https://carbon-ratings.com/eth-report-2022) - _CCRI_ +- [Consumo energetico di Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8) ## Argomenti correlati {#related-topics} - [Visione di Ethereum](/roadmap/vision/) - [La Beacon Chain](/roadmap/beacon-chain) - [La Fusione](/roadmap/merge/) -- [Frammentazione](/roadmap/beacon-chain/) diff --git a/src/content/translations/it/enterprise/index.md b/src/content/translations/it/enterprise/index.md index 20b4bc8ebf8..a8dcaa286da 100644 --- a/src/content/translations/it/enterprise/index.md +++ b/src/content/translations/it/enterprise/index.md @@ -62,6 +62,7 @@ Alcuni sforzi collaborativi per rendere la rete Ethereum aziendale più intuitiv - [Tenderly](https://tenderly.co) _una piattaforma di sviluppo Web3 che fornisce elementi di debug, osservabilità e infrastruttura per lo sviluppo, il test, il monitoraggio e il funzionamento dei contratti intelligenti._ - [Unibright](https://unibright.io/) _team di specialisti della blockchain, architetti, sviluppatori e consulenti con più di 20 anni di esperienza in processi di business e integrazione_ - [Zero Services GmbH](https://www.zeroservices.eu/) _provider di servizi gestiti si diffonde in co-sedi in Europa e Asia. Fa funzionare e monitora i tuoi nodi in modo sicuro e affidabile_ +- [Zeeve](https://www.zeeve.io/) _fornisce una gamma di prodotti e strumenti per creare su Ethereum, nonché infrastruttura e API per le applicazioni Enterprise Web3._ ### Strumenti e librerie {#tooling-and-libraries} diff --git a/src/content/translations/it/enterprise/private-ethereum/index.md b/src/content/translations/it/enterprise/private-ethereum/index.md index 4a5d7452a92..242998835b8 100644 --- a/src/content/translations/it/enterprise/private-ethereum/index.md +++ b/src/content/translations/it/enterprise/private-ethereum/index.md @@ -24,4 +24,4 @@ Diverse organizzazioni si sono adoperate per rendere più intuitiva Ethereum per - [Hyperledger Besu](https://www.hyperledger.org/use/besu) _Client open source di Ethereum sviluppato con licenza Apache 2.0 e scritto in Java, che include diversi algoritmi di consenso, tra cui PoW e PoA (IBFT, IBFT 2.0, Etherhash e Clique). Gli schemi di autorizzazione completi adottati sono progettati specificamente per l'uso in un ambiente consortile._ - [Hyperledger Burrow](https://www.hyperledger.org/projects/hyperledger-burrow) _Client modulare della blockchain con un interprete autorizzato del contratto intelligente, sviluppato parzialmente alla specifica della Macchina Virtuale di Ethereum (EVM)_ - [Kaleido](https://kaleido.io/) _Piattaforma a tutto tondo per lo sviluppo e l'esecuzione di ecosistemi aziendali ibridi adatti a diversi cloud_ -- [Quorum](https://consensys.net/quorum/) _Piattaforma blockchain aziendale open source basata su Ethereum con funzionalità aziendali di livello avanzato che garantiscono privacy, gestione dei permessi e prestazioni elevate_ +- [Quorum](https://consensys.net/quorum/) _è una piattaforma di blockchain open source basata su Ethereum con funzionalità di grado imprenditoriale, che consentono privacy, permessi e prestazioni_ [Zeeve](https://www.zeeve.io/) _fornisce una gamma di prodotti e strumenti per creare su Ethereum, nonché infrastruttura e API per le applicazioni di Imprese del Web3._ diff --git a/src/content/translations/it/governance/index.md b/src/content/translations/it/governance/index.md index d350572073b..e8a948782d7 100644 --- a/src/content/translations/it/governance/index.md +++ b/src/content/translations/it/governance/index.md @@ -25,7 +25,7 @@ La governance di Ethereum è il processo attraverso il quale vengono apportate m ### Governance on-chain e off-chain {#on-chain-vs-off-chain} -La tecnologia blockchain rende possibili nuove modalità di governance, conosciute come governance on-chain. Per governance on-chain si intende che le proposte di modifica al protocollo sono decise tramite il voto degli stakeholder, che in genere detengono un governance token, e la votazione avviene sulla blockchain. In alcune forme di governance on-chain, le modifiche proposte al protocollo sono già scritte nel codice e vengono implementate automaticamente nel caso vengano approvate dagli stakeholder. +La tecnologia blockchain rende possibili nuove modalità di governance, conosciute come governance on-chain. Per governance on-chain si intende che le proposte di modifica al protocollo sono decise tramite il voto degli stakeholder, che in genere detengono un governance token, e la votazione avviene sulla blockchain. In alcune forme di governance on-chain, le modifiche proposte al protocollo sono già scritte nel codice e vengono implementate automaticamente nel caso in cui vengano approvate dagli stakeholder tramite la sottoscrizione di una transazione. Con governance off-chain si intende invece l'approccio opposto, ovvero quando le decisioni di modifica al protocollo passano attraverso un processo informale di discussione e, se approvate, vengono implementate nel codice. @@ -48,7 +48,7 @@ Ci sono diversi stakeholder nella [ community Ethereum](/community/), ognuno dei - **Sviluppatori di applicazioni/strumenti**: queste persone scrivono applicazioni che vengono eseguite sulla blockchain Ethereum (ad esempio DeFi, NFT, ecc.) o sviluppano strumenti per interagire con Ethereum (ad esempio wallet, suite di test, ecc.). [Di più sulle dapp](/dapps/). - **Gestori di nodi**: queste persone eseguono nodi che propagano blocchi e transazioni, rifiutando eventuali transazioni o blocchi invalidi che intercettano. [Maggiori informazioni sui nodi](/developers/docs/nodes-and-clients/). - **Autori EIP**: queste persone propongono modifiche al protocollo Ethereum, sotto forma di Ethereum Improvement Proposal (EIP). [Maggiori informazioni sulle EIP](/eips/). -- **Miner/Validatori**: queste persone eseguono nodi che possono aggiungere nuovi blocchi alla blockchain Ethereum. +- **Validatori**: queste persone eseguono nodi che possono aggiungere nuovi blocchi alla blockchain Ethereum. - **Sviluppatori del protocollo** (o "Core Developer" ): queste persone mantengono le varie implementazioni di Ethereum (ad esempio go-ethereum, Nethermind, Besu ed Erigon a livello di esecuzione o Prysm, Lighthouse, Nimbus, Teku e Lodestar a livello di consenso). [Maggiori informazioni sui client di Ethereum](/developers/docs/nodes-and-clients/). _Nota: chiunque può far parte di più gruppi (ad esempio uno sviluppatore di protocollo può sostenere un EIP, essere validatore sulla beacon chain e usare applicazioni DeFi). Tuttavia, per chiarezza concettuale risulta più facile distinguerli._ @@ -91,7 +91,7 @@ Benché molto semplificato, questo flusso può dare un'idea delle fasi principal ### Comprendere il lavoro fatto in precedenza {#prior-work} -Gli EIP Champion dovrebbero familiarizzare con il lavoro e le proposte fatte in precedenza prima di creare una EIP che possa essere considerata seriamente per il rilascio sulla rete principale di Ethereum. In questo modo, si spera che l'EIP possa portare qualcosa di nuovo, che non sia già stato rifiutato in precedenza. Le tre principali fonti di informazioni a questo proposito sono [l'EIP repository](https://github.com/ethereum/eips), [Ethereum Magicians](https://ethereum-magicians.org/) ed [ethresear.ch](https://ethresear.ch/). +Gli EIP Champion dovrebbero familiarizzare con il lavoro e le proposte fatte in precedenza prima di creare una EIP che possa essere considerata seriamente per il rilascio sulla rete principale di Ethereum. In questo modo, si spera che l'EIP possa portare qualcosa di nuovo, che non sia già stato rifiutato in precedenza. Le tre principali fonti di informazioni a questo proposito sono [l'EIP repository](https://github.com/ethereum/EIPs), [Ethereum Magicians](https://ethereum-magicians.org/) ed [ethresear.ch](https://ethresear.ch/). ### Gruppi di lavoro {#working-groups} @@ -99,9 +99,9 @@ La bozza iniziale di una EIP difficilmente verrà implementata sulla rete princi ### Consenso della community {#community-consensus} -Mentre alcune EIP sono semplici miglioramenti tecnici con sfumature minime, altre sono più complesse e implicano compromessi che interesseranno più stakeholder in modi diversi. Questo significa che alcune EIP finiscono per essere più discusse nella community rispetto ad altre. +Mentre alcune EIP sono semplici miglioramenti tecnici con sfumature minime, altre sono più complesse e implicano compromessi che influenzeranno diverse parti interessate, in modi differenti. Questo significa che alcune EIP finiscono per essere più discusse nella community rispetto ad altre. -Non c'è una modalità definita su come gestire le proposte controverse. Dato che gli sviluppatori del protocollo non hanno modo di forzare le persone ad adottare gli upgrade, evitano generalmente di implementare le EIP per le quali le discussioni superano i benefici per l'intera community. +Non c'è una modalità definita su come gestire le proposte controverse. Questo è il risultato del design decentralizzato di Ethereum in cui nessun singolo gruppo di stakeholder può costringere l'altro attraverso la forza bruta: gli sviluppatori di protocollo possono scegliere di non implementare modifiche di codice; gli operatori dei nodi possono scegliere di non eseguire l'ultimo client Ethereum; i team di applicazioni e gli utenti possono scegliere di non effettuare transazioni sulla catena. Dato che gli sviluppatori del protocollo non hanno modo di forzare le persone ad adottare gli upgrade, evitano generalmente di implementare le EIP per le quali le discussioni superano i benefici per l'intera community. Gli EIP Champion dovrebbero sollecitare i feedback da tutti gli stakeholder interessati. Se ti ritrovi ad essere un EIP Champion di un'EIP controversa, dovresti provare a rispondere alle obiezioni cercando di raggiungere un consenso. Date le dimensioni e la diversità della community di Ethereum, non vi sono singoli parametri (es. un voto con moneta) utilizzabili per misurare il consenso della community e gli EIP Champion dovrebbero adattarsi alle circostanze della proposta. @@ -147,13 +147,13 @@ La capacità di eseguire il fork di fronte a divergenze politiche, filosofiche o -## Sviluppo della beacon chain {#beacon-chain} +## Governance della beacon chain {#beacon-chain} Il processo di governance di Ethereum spesso rinuncia a velocità ed efficienza a favore di apertura e inclusività. Al fine di accelerare lo sviluppo della Beacon Chain, è stata lanciata separatamente dalla rete proof-of-work di Ethereum e ha seguito le proprie pratiche di governance. -Lo sviluppo di specifiche e implementazioni è sempre stato totalmente open source; non sono stati invece utilizzati i processi formali descritti sopra per proporre gli aggiornamenti. Questo ha consentito a ricercatori e implementatori di specificare e concordare le modifiche più rapidamente. +Lo sviluppo di specifiche e implementazioni è sempre stato totalmente open source, non sono stati invece utilizzati i processi formali descritti sopra per proporre gli aggiornamenti. Questo ha consentito a ricercatori e implementatori di specificare e concordare le modifiche più rapidamente. -Quando la Beacon Chain si fonderà con il livello di esecuzione di Ethereum, il processo di governance per proporre le modifiche sarà armonizzato. Questo processo per implementare la fusione è [già in corso](https://eips.ethereum.org/EIPS/eip-3675). +Quando la Beacon Chain si è fusa al livello d'esecuzione di Ethereum il 15 september 2022 La Fusione è stata completata, come parte dell'[aggiornamento di rete di Parigi](https://ethereum.org/en/history/#paris). La proposta [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675) è stata modificata da 'Ultimo Appello' a 'Definitiva', completando la transizione al proof-of-stake. Maggiori informazioni sulla fusione @@ -176,7 +176,7 @@ Quando la Beacon Chain si fonderà con il livello di esecuzione di Ethereum, il La governance in Ethereum non è definita rigidamente. I vari partecipanti della comunità hanno diverse prospettive a riguardo. Eccone alcune: - [Note sulla governance della blockchain](https://vitalik.ca/general/2017/12/17/voting.html) - _Vitalik Buterin_ -- [Come funziona la governance di Ethereum?](https://cryptotesters.com/blog/ethereum-governance) – _Cryptotesters_ +- [Come funziona la governance di Ethereum?](https://cryptotesters.com/blog/ethereum-governance) – _Cryptotester_ - [Come funziona la governance di Ethereum](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_ - [Cos'è uno sviluppatore core di Ethereum?](https://hudsonjameson.com/2020-06-22-what-is-an-ethereum-core-developer/) - _Hudson Jameson_ - [Governance, parte 2: la plutocrazia è ancora una brutta cosa](https://vitalik.ca/general/2018/03/28/plutocracy.html) - _Vitalik Buterin_ diff --git a/src/content/translations/it/guides/how-to-create-an-ethereum-account/index.md b/src/content/translations/it/guides/how-to-create-an-ethereum-account/index.md new file mode 100644 index 00000000000..1eeb6668f34 --- /dev/null +++ b/src/content/translations/it/guides/how-to-create-an-ethereum-account/index.md @@ -0,0 +1,68 @@ +--- +title: Come "creare" un conto di Ethereum +description: Una guida passo-passo sulla creazione di un conto di Ethereum utilizzando un portafoglio. +lang: it +--- + +# Come "registrare" un conto di Ethereum + +Chiunque può creare gratuitamente un conto di Ethereum grazie a una specifica tipologia di app comunemente nota come portafoglio. I portafogli creano e proteggono le chiavi che ti consentono di detenere, inviare e ricevere criptovalute. Inoltre, puoi connetterti ai progetti su Ethereum che ti consentiranno di commerciare NFT, scambiare token, accedere a giochi e molto altro. + +A differenza dell'apertura di un nuovo conto presso un'azienda, la creazione di un conto di Ethereum avviene gratuitamente, privatamente e senza chiedere un'autorizzazione. I conti sono controllati da chiavi che il software del tuo portafoglio ti aiuta a generare, che non sono rilasciate da terzi né sono conservate in un registro centrale. + +## Fase 1: sfoglia il nostro elenco di portafogli + +Un portafoglio è come un conto bancario online per Ethereum. Esistono decine di portafogli diversi tra cui scegliere: per mobile, desktop o persino estensioni per browser. Il nostro elenco curato di portafogli sicuri è un buon punto di partenza. + + + Trova un portafoglio + + +## Fase 2: scegli un portafoglio adatto alle tue esigenze + +Se non hai esperienza, puoi attivare il filtro "Senza conoscenza di criptovalute" per visualizzare soltanto quei portafogli che includono tutte le funzionalità necessarie che pensiamo sarebbero particolarmente adatte per i principianti. Esistono poi altri filtri del profilo per provvedere alle tue esigenze. + +## Fase 3: scarica e installa l'app del tuo portafoglio + +Una volta scelto un portafoglio specifico, visitane il sito web ufficiale o l'app store, scaricalo e installalo. Dovrebbero essere tutti gratuiti. + +## Fase 4: apri l'app e genera o importa il tuo conto di Ethereum + +La prima volta che apri il tuo nuovo portafoglio, ti potrebbe esser chiesto di scegliere tra creare un nuovo conto o importarne uno esistente. Clicca sulla creazione di un nuovo conto. + +## Fase 5: memorizza la tua frase di recupero + +Alcune app ti chiederanno di salvare una frase di recupero segreta. Mantenere questa frase di recupero segreta al sicuro è estremamente importante! Chiunque conosca questa frase di recupero segreta può prendere il controllo di tutti i tuoi conti generati da tali parole. Non condividerla mai con nessuno. Questa frase dovrebbe contenere da 12 a 24 parole generate casualmente (l'ordine delle parole è importante). + +Una volta salvata la tua frase di recupero, dovresti vedere il pannello di controllo del tuo portafoglio con il tuo saldo. Consulta la nostra guida: [come utilizzare un portafoglio.](/guides/how-to-use-a-wallet) + +
+ + +
Vuoi saperne di più?
+ + Visualizza le altre guide + + + +## Domande frequenti + +### Il mio portafoglio e il mio conto di Ethereum sono la stessa cosa? + +No, proprio come l'online banking, puoi avere molti conti differenti, tutti memorizzati nell'applicazione di un portafoglio. La tua frase di 12 o 24 parole li protegge tutti: è come il seme di un grande albero (per cui, devi tenerla al sicuro). Ogni ramo dell'albero regge una chiave e ogni chiave è uno dei tuoi conti. Se perdi l'accesso al portafoglio (cioè, se il tuo albero viene abbattuto), puoi sempre ripristinare tutti i tuoi diversi conti utilizzando un altro software e lo stesso seme (che farà crescere sempre lo stesso albero). + +### Posso inviare bitcoin a un indirizzo di Ethereum, o ether a un indirizzo di Bitcoin? + +No, non puoi. Bitcoin ed ether esistono su due reti separate (cioè, blockchain differenti), ognuna con i propri modelli contabili e formati degli indirizzi. Ci sono stati vari tentativi di collegare le due diverse reti, di cui il più attivo al momento è [Wrapped bitcoin o WBTC](https://www.bitcoin.com/get-started/what-is-wbtc/). Questa non è una sponsorizzazione, poiché WBTC è una soluzione di custodia (a significare che un singolo gruppo di persone controlla certe funzioni critiche) ed è qui indicata per soli scopi informativi. + +### Se possiedo un indirizzo ETH, possiedo lo stesso indirizzo su altre blockchain? + +Puoi utilizzare lo stesso indirizzo su tutte le blokchain compatibili con l'EVM (se hai il tipo di portafoglio con una frase di recupero). Questo [elenco](https://chainlist.org/) ti mostrerà quali blockchain puoi utilizzare con lo stesso indirizzo. Alcune blockchain, come Bitcoin, implementano una serie di regole di rete completamente separata, e ti servirà un indirizzo diverso con un formato differente. Se hai un portafoglio di contratti intelligenti, dovresti consultare il sito web del prodotto per ulteriori informazioni su quali blockchain sono supportate. + +### Avere il proprio portafoglio è più sicuro di mantenere i miei fondi su una borsa? + +Sì, è un'opzione molto più sicura perché nessun altro avrà accesso ai tuoi fondi. Sfortunatamente, esistono molti esempi di borse fallite che hanno presentato istanza di fallimento, causando la perdita da parte degli utenti dei propri risparmi tenuti in custodia. Hack, conti congelati o prelievi bloccati sono alcuni altri rischi comuni. Possedere un portafoglio (con una frase di recupero) è il metodo migliore per salvaguardare le tue risorse. Ciononostante, una frase di recupero mal protetta ti espone potenzialmente a più rischi rispetto a far gestire le tue chiavi da una borsa. Assicurati di proteggere bene la tua frase di recupero. + +### Se perdo il mio portafoglio su telefono/hardware, devo riutilizzare la stessa app del portafoglio per recuperare i fondi perduti? + +No, puoi usare quasi qualsiasi portafoglio poiché il procedimento di recupero è ampiamente standardizzato. Ciò significa che puoi inserire la stessa frase di 12 o 24 parole in gran parte dei portafogli e il tuo conto sarà ripristinato. Se mai dovessi farlo, sii cauto: è meglio assicurarsi di non essere connessi a Internet quando si recupera il proprio portafoglio, così che la tua frase di recupero non trapeli accidentalmente. Spesso è impossibile recuperare i fondi perduti senza la frase di recupero. diff --git a/src/content/translations/it/guides/how-to-revoke-token-access/index.md b/src/content/translations/it/guides/how-to-revoke-token-access/index.md new file mode 100644 index 00000000000..8ba69f23ccf --- /dev/null +++ b/src/content/translations/it/guides/how-to-revoke-token-access/index.md @@ -0,0 +1,73 @@ +--- +title: Come revocare l'accesso dei contratti intelligenti ai tuoi fondi di criptovalute +description: Una guida su come revocare l'accesso di sfruttamento al token del contratto intelligente +lang: it +--- + +# Come revocare l'accesso dei contratti intelligenti ai tuoi fondi di criptovalute + +Questa guida ti spiegherà come visualizzare l'elenco completo dei contratti intelligenti ai quali hai permesso l'accesso ai tuoi fondi e come annullarli. + +Talvolta gli sviluppatori malevoli creano backdoor nei contratti intelligenti che consentono l'accesso ai fondi di utenti inconsapevoli che interagiscono con il contratto intelligente. Ciò che spesso si verifica è che tali piattaforme chiedono all'utente l'autorizzazione a spendere un **numero illimitato di token** nel tentativo di risparmiare piccole quantità di carburante in futuro, ma ciò presenta un rischio maggiore. + +Una volta che una piattaforma ha diritti d'accesso illimitati a un token sul tuo portafoglio, può spenderli tutti, anche se hai prelevato i tuoi fondi da tale piattaforma sul tuo portafoglio. Gli utenti malevoli possono comunque accedere ai tuoi fondi e prelevarli nei propri portafogli senza che ti rimanga alcuna opzione di recupero. + +Le sole forme di protezione sono astenersi dall'utilizzo di nuovi progetti non testati, approvare soltanto ciò che è necessario, o revocare regolarmente l'accesso. Quindi, come si fa? + +## Fase 1: utilizzare strumenti di revoca dell'accesso + +Svariati siti web ti consentono di visualizzare e revocare i contratti intelligenti connessi al tuo indirizzo. Visita il sito web e connetti il tuo portafoglio: + +- [Ethallowance](https://ethallowance.com/) (Ethereum) +- [Etherscan](https://etherscan.io/tokenapprovalchecker) (Ethereum) +- [Cointool](https://cointool.app/approve/eth) (svariate reti) +- [Revoke](https://revoke.cash/) (svariate reti) +- [Unrekt](https://app.unrekt.net/) (svariate reti) +- [EverRevoke](https://everrise.com/everrevoke/) (svariate reti) + +## Fase 2: connetti il tuo portafoglio + +Una volta sul sito web, clicca su "Connetti portafoglio". Il sito web dovrebbe richiederti di connettere il tuo portafoglio. + +Assicurati di utilizzare la stessa rete nel tuo portafoglio e sul sito web. Vedrai soltanto i contratti intelligenti correlati alla rete selezionata. Ad esempio, se ti connetti alla Rete Principale di Ethereum, vedrai soltanto i contratti di Ethereum, non quelli di altre catene come Polygon. + +## Fase 3: seleziona un contratto intelligente che desideri revocare + +Dovresti vedere tutti i contratti aventi l'accesso consentito ai tuoi token e il loro limite di spesa. Trova quello che desideri risolvere. + +Se non sai quale contratto scegliere, puoi revocarli tutti. Non creerà alcun problema per te, ma dovrai garantire una nuova serie di autorizzazioni alla prossima interazione con uno qualsiasi di questi contratti. + +## Fase 4: revocare l'accesso ai tuoi fondi + +Una volta fatto clic su revoca, dovresti visualizzare un nuovo suggerimento di transazione nel tuo portafoglio. Ciò è prevedibile. Dovrai pagare la commissione affinché l'annullamento vada a buon fine. A seconda della rete, l'elaborazione può richiedere da uno a svariati minuti. + +Ti consigliamo di ricaricare lo strumento di revoca dopo qualche minuto e di riconnettere il tuo portafoglio, per ricontrollare se il contratto revocato è scomparso dall'elenco. + +Ti consigliamo di non consentire mai l'accesso illimitato ai tuoi token ai progetti e di revocare regolarmente gli accessi di allowance a tutti i token. Revocare l'accesso al token non dovrebbe mai risultare in una perdita di fondi, specialmente se utilizzi i suddetti strumenti. + +
+ + +
Vuoi scoprire di più?
+ + Visualizza le altre guide + + + +## Domande frequenti + +### Revocare l'accesso al token fa cessare anche lo staking, i pool, i prestiti, ecc.? + +No, non influenzerà alcuna tua strategia di DeFi. Manterrai tue posizioni e continuerai a ricevere ricompense, ecc. + +### Disconnettere un portafoglio da un progetto equivale a rimuovere le autorizzazioni a utilizzare i miei fondi? + +No, se disconnetti il tuo portafoglio dal progetto, ma hai garantito al token le autorizzazioni di allowance, può ancora utilizzare questi token. Devi revocare tale accesso. + +### Quando scadranno le autorizzazioni del contratto? + +Non esistono date di scadenza delle autorizzazioni dei contratti. Se concedi le autorizzazioni al contratto, sono utilizzabili persino anni dopo la loro concessione. + +### Perché i progetti impostano allowance dei token illimitata? + +Spesso i progetti lo fanno per ridurre il numero di richieste necessarie, a significare che l'utente deve approvare soltanto una volta, pagando la commissione di transazione un'unica volta. Sebbene sia comodo, può essere pericoloso che gli utenti approvino senza cautela, su siti web non affidabili o controllati. Alcuni portafogli ti consentono di limitare manualmente la quantità di token approvati per limitare i tuoi rischi. Consulta il fornitore del tuo portafoglio per ulteriori informazioni. diff --git a/src/content/translations/it/guides/how-to-swap-tokens/index.md b/src/content/translations/it/guides/how-to-swap-tokens/index.md new file mode 100644 index 00000000000..bc6365be8e4 --- /dev/null +++ b/src/content/translations/it/guides/how-to-swap-tokens/index.md @@ -0,0 +1,67 @@ +--- +title: Come scambiare token +description: Una guida su come scambiare i token su Ethereum. +lang: it +--- + +# Come scambiare token + +Sei stanco di cercare una borsa che elenchi tutti i tuoi token preferiti? Puoi scambiare gran parte dei token utilizzando le borse decentralizzate. + +Uno scambio di token comporta lo scambio di due risorse differenti esistenti sulla rete di Ethereum, ad esempio ETH per DAI (un token ERC-20). Il processo è molto veloce ed economico. Dovrai avere un portafoglio di criptovalute per scambiare token. + +**Prerequisiti:** + +- avere un portafoglio di criptovalute, puoi seguire questo tutorial: [Come "registrare" un conto di Ethereum](/guides/how-to-register-an-ethereum-account/) +- aggiungere fondi al tuo portafoglio + +## 1. Connetti il tuo portafoglio alla borsa decentralizzata (DEX) di tua scelta + +Alcune borse popolari sono: + +- [Uniswap](https://app.uniswap.org/#/swap) +- [Sushiswap](https://www.sushi.com/swap) +- [1Inch](https://app.1inch.io/#/1/unified/swap/ETH/DAI) +- [Curve](https://curve.fi/#/ethereum/swap) + +Se desideri scoprire di più su cosa sia la DeFi e sul funzionamento di questi nuovi tipi di borse, consigliamo la [Libreria Kernel](https://library.kernel.community/Topic+-+DeFi/Topic+-+DeFi). + +## 2. Seleziona la coppia di token che desideri scambiare + +Ad esempio, ETH e DAI. Assicurati di avere fondi in uno dei due token. ![Interfaccia comune per lo scambio](./swap1.png) + +## 3. Inserisci l'importo di token che desideri scambiare e clicca su scambia + +La borsa calcolerà automaticamente quanti token otterrai. + +![Interfaccia comune per lo scambio](./swap2.png) + +## 4. Conferma la transazione + +Ricontrolla i dettagli della transazione. Controlla il tasso di cambio e qualsiasi altra commissione per evitare brutte sorprese. + +![Interfaccia comune per ricontrollare la transazione](./swap3.png) + +## 5. Attendi l'elaborazione della transazione + +Puoi visualizzare il progresso della transazione su qualsiasi esploratore della blockchain. Questo processo non dovrebbe richiedere più di 10 minuti. + +Riceverai automaticamente i token scambiati nel tuo portafoglio, una volta elaborata la transazione. +
+ + +
Vuoi scoprire di più?
+ + Visualizza le altre guide + + + +## Domande frequenti + +### Posso scambiare ETH per BTC dal mio portafoglio? + +No, puoi soltanto scambiare token nativi della rete di Ethereum, quali ETH, token ERC-20 o NFT. Puoi scambiare soltanto le forme "wrapped" di Bitcoin che risiedono su Ethereum. + +### Cos'è lo scivolamento? + +È la differenza tra il tuo tasso di cambio previsto e quello effettivo. diff --git a/src/content/translations/it/guides/how-to-use-a-bridge/index.md b/src/content/translations/it/guides/how-to-use-a-bridge/index.md new file mode 100644 index 00000000000..2507fb5375c --- /dev/null +++ b/src/content/translations/it/guides/how-to-use-a-bridge/index.md @@ -0,0 +1,70 @@ +--- +title: Come collegare i token al livello 2 +description: Una guida a come spostare i token da Ethereum al livello 2 utilizzando un ponte. +lang: it +--- + +# Come collegare i token al livello 2 + +Se c'è molto traffico su Ethereum, può diventare costoso. Una soluzione è creare nuovi "livelli", ossia reti differenti che operano in modi similari alla stessa Ethereum. Questi cosiddetti Livelli 2 aiutano a ridurre la congestione e i costi su Ethereum elaborando molte altre transazioni a commissioni inferiori, memorizzandone i risultati su Ethereum soltanto una volta ogni tanto. Come tali, questi livelli 2 ci consentono di effettuare transazioni a maggiori velocità e costi ridotti. Molti progetti di criptovalute popolari si stanno spostando ai livelli 2 per questi vantaggi. Il metodo più semplice per spostare i token da Ethereum al livello 2 è utilizzare un ponte. + +**Prerequisiti:** + +- avere un portafoglio di criptovalute, puoi seguire questo tutorial: [Come "registrare" un conto di Ethereum](/guides/how-to-register-an-ethereum-account/) +- aggiungere fondi al tuo portafoglio + +## 1. Determina quale rete di livello 2 desideri utilizzare + +Puoi scoprire di più sui diversi progetti e i collegamenti importanti sulla nostra [pagina del livello 2](/layer-2/). + +## 2. Vai al ponte selezionato + +Alcuni livelli 2 popolari sono: + +- [Ponte Arbitrum](https://bridge.arbitrum.io/?l2ChainId=42161) +- [Ponte Optimism](https://app.optimism.io/bridge/deposit) +- [Ponte della rete Boba](https://gateway.boba.network/) + +## 3. Connettiti al ponte con il tuo portafoglio + +Assicurati che il tuo portafoglio sia connesso alla Rete Principale di Ethereum. Altrimenti, il sito web ti richiederà automaticamente di cambiare rete. + +![Interfaccia comune per collegare token](./bridge1.png) + +## 4. Specifica l'importo e sposta i fondi + +Ricontrolla l'importo che otterrai in cambio sulla rete di livello 2 e le commissioni per evitare spiacevoli sorprese. + +![Interfaccia comune per collegare token](./bridge2.png) + +## 5. Conferma la transazione nel tuo portafoglio + +Dovrai pagare una commissione sotto forma di ETH per elaborare la transazione. + +![Interfaccia comune per collegare token](./bridge3.png) + +## 6. Attendi che i tuoi fondi siano spostati + +Questo procedimento non dovrebbe richiedere più di 10 minuti. + +## 7. Aggiungi la rete di livello 2 selezionata al tuo portafoglio (facoltativo) + +Puoi utilizzare [chainlist.org](http://chainlist.org) per trovare i dettagli RPC della rete. Una volta che la rete è aggiunta e la transazione è terminata, dovresti visualizzare i token nel tuo portafoglio. +
+ + +
Vuoi scoprire di più?
+ + Visualizza le altre guide + + + +## Domande frequenti + +### E se ho dei fondi su una borsa? + +Dovresti riuscire a prelevare su qualche livello 2 direttamente da una borsa. Consulta la sezione "Sposta al livello 2" della nostra [Pagina del Livello 2](/layer-2/) per ulteriori informazioni. + +### Posso tornare alla Rete Principale di Ethereum dopo aver collegato i miei token al L2? + +Sì, puoi sempre spostare nuovamente i tuoi fondi nella Rete Principale utilizzando lo stesso ponte. diff --git a/src/content/translations/it/guides/how-to-use-a-wallet/index.md b/src/content/translations/it/guides/how-to-use-a-wallet/index.md new file mode 100644 index 00000000000..0d41d1412a6 --- /dev/null +++ b/src/content/translations/it/guides/how-to-use-a-wallet/index.md @@ -0,0 +1,88 @@ +--- +title: Come utilizzare un portafoglio +description: Una guida che spiega come inviare, ricevere token e connettersi a progetti web3. +lang: it +--- + +# Come utilizzare un portafoglio + +Impara come gestire tutte le funzioni di base di un portafoglio. Se non ne hai ancora uno, consulta il nostro [Come "registrare" un conto di Ethereum](/guides/how-to-register-an-ethereum-account/). + +## Apri il tuo portafoglio + +Dovresti vedere un pannello di controllo che probabilmente mostrerà il tuo saldo e contiene i pulsanti per inviare e ricevere token. + +## Ricevere criptovalute + +Desideri ricevere criptovalute nel tuo portafoglio? + +Ogni conto di Ethereum ha il proprio indirizzo di destinazione, una sequenza univoca di numeri e lettere. L'indirizzo funziona come un numero di conto bancario. Gli indirizzi di Ethereum inizieranno sempre con "0x". Puoi condividere questo indirizzo con chiunque: farlo è sicuro. + +Il tuo indirizzo (talvolta detto "chiave pubblica") è come l'indirizzo di casa tua: devi comunicarlo alle persone affinché ti possano trovare. Farlo è sicuro, poiché puoi sempre chiudere la porta con un'altra chiave che controlli soltanto tu così che nessuno possa entrare anche se sa dove vivi. + +Devi fornire il tuo indirizzo pubblico a chiunque voglia inviarti denaro. Molte app del portafoglio ti consentono di copiare il tuo indirizzo o di mostrare un codice QR da scansionare per facilitare l'utilizzo. Evita di digitare manualmente qualsiasi indirizzo di Ethereum. Ciò può facilmente comportare errori di trascrizione o perdita di fondi. + +App diverse potrebbero variare o utilizzare un linguaggio differente, ma dovrebbero guidarti lungo un processo simile se stai provando a trasferire fondi. + +1. Apri l'app del tuo portafoglio. +2. Clicca su "Ricevi" (o un'opzione simile). +3. Copia il tuo indirizzo di Ethereum negli appunti. +4. Fornisci il tuo indirizzo di destinazione di Ethereum al mittente. + +## Invia criptovalute + +Vorresti inviare ETH a un altro portafoglio? + +1. Apri l'app del tuo portafoglio. +2. Ottieni l'indirizzo di destinazione e assicurati di essere connesso alla stessa rete del destinatario. +3. Inserisci l'indirizzo di destinazione o scansiona un codice QR con la tua fotocamera, così da non dover scrivere manualmente l'indirizzo. +4. Fai clic su un pulsante "Invia" nel tuo portafoglio (o un'alternativa simile). + +![Invia il campo per l'indirizzo delle criptovalute](./send.png) +
+ +5. Molte risorse, come DAI o USDC, esistono su più reti. Trasferendo i token di criptovalute, assicurati che il destinatario stia utilizzando la tua stessa rete, poiché non sono intercambiabili. +6. Assicurati che il tuo portafoglio abbia ETH a sufficienza per coprire la commissione di transazione, che varia a seconda delle condizioni di rete. Gran parte dei portafogli aggiungeranno automaticamente la commissione suggerita alla transazione, che puoi poi confermare. +7. Una volta elaborata la tua transazione, l'importo di criptovalute corrispondente apparirà nel conto del destinatario. Questo potrebbe richiedere da qualche secondo a qualche minuto, a seconda dell'utilizzo corrente della rete. + +## Connettersi ai progetti + +Il tuo indirizzo sarà lo stesso in tutti i progetti di Ethereum. Non devi registrarti individualmente a ogni progetto. Una volta che hai un portafoglio, puoi connetterti a qualsiasi progetto di Ethereum senza alcuna informazione aggiuntiva. Non sono necessarie email o qualsiasi altra informazione personale. + +1. Visita il sito web di qualsiasi progetto. +2. Se la pagina iniziale del progetto è una semplice descrizione statica del progetto, dovresti poter cliccare su un pulsante "Apri l'App" nel menu, che ti condurrà all'app web effettiva. +3. Una volta nell'app, clicca su "Connettiti" + +![Pulsante che consente all'utente di connettersi al sito web con un portafoglio](./connect1.png) + +4. Seleziona il tuo portafoglio dall'elenco delle opzioni fornite. Se non riesci a vedere il tuo portafoglio, potrebbe essere nascosto sotto l'opzione "WalletConnect". + +![Selezionare da un elenco di portafogli con cui connettersi](./connect2.png) + +5. Conferma la richiesta di firma nel tuo portafoglio per stabilire la connessione. **Firmare questo messaggio non dovrebbe richiedere di spendere ETH**. +6. È tutto! Inizia a usare l'app. Puoi trovare qualche progetto interessante sulla nostra [pagina delle dApp](/dapps/#explore).
+ + +
Vuoi scoprire di più?
+ + Visualizza le altre guide + + + +## Domande frequenti + +### Se possiedo un indirizzo ETH, possiedo lo stesso indirizzo su altre blockchain? + +Puoi utilizzare lo stesso indirizzo su tutte le blokchain compatibili con l'EVM (se hai il tipo di portafoglio con una frase di recupero). Questo [elenco](https://chainlist.org/) ti mostrerà quali blockchain puoi utilizzare con lo stesso indirizzo. Alcune blockchain, come Bitcoin, implementano una serie di regole di rete completamente separata, e ti servirà un indirizzo diverso con un formato differente. Se hai un portafoglio di contratti intelligenti, dovresti consultare il sito web del prodotto per ulteriori informazioni su quali blockchain sono supportate. + +### Posso utilizzare lo stesso indirizzo su diversi dispositivi? + +Sì, puoi utilizzare lo stesso indirizzo su più dispositivi. Tecnicamente i portafogli sono soltanto un'interfaccia per mostrarti il tuo saldo ed effettuare transazioni, il tuo conto non è memorizzato nel portafoglio ma sulla blockchain. + +### Non ho ricevuto le criptovalute, dove posso controllare lo stato di una transazione? + +Puoi utilizzare gli [esploratori di blocchi](/developers/docs/data-and-analytics/block-explorers/) per visualizzare lo stato di qualsiasi transazione in tempo reale. Tutto ciò che devi fare è cercare l'indirizzo del tuo portafoglio o l'ID della transazione. + +### Posso annullare o revocare le transazioni? + +No, una volta confermata una transazione, non puoi annullarla. diff --git a/src/content/translations/it/guides/index.md b/src/content/translations/it/guides/index.md new file mode 100644 index 00000000000..9de310d140c --- /dev/null +++ b/src/content/translations/it/guides/index.md @@ -0,0 +1,29 @@ +--- +title: Guide su Ethereum +description: Una raccolta di guide pratiche per principianti che illustrano le basi sull'utilizzo di Ethereum. +lang: it +--- + +# Guide su Ethereum + +Vuoi iniziare il tuo viaggio in Ethereum? Ethereum non è una società con un'assistenza vincolata dagli script, ma queste guide pratiche ti aiuteranno a capire come iniziare. + +## Primi passi + +1. [Come "creare" un conto di Ethereum](/guides/how-to-create-an-ethereum-account/) - Chiunque può creare gratuitamente un portafoglio. Questa guida ti mostrerà come iniziare. + +2. [Come utilizzare un portafoglio](/guides/how-to-use-a-wallet/) - Un'introduzione alle funzionalità di base di qualsiasi portafoglio e come utilizzarle. + +## Fondamenti di sicurezza + +1. [Come revocare l'accesso del contratto intelligente ai tuoi fondi di criptovalute](/guides/how-to-revoke-token-access/) - Se improvvisamente vedi una transazione nel tuo portafoglio che non hai avviato, questa guida ti insegnerà come impedire che si verifichi nuovamente. + +## Uso di Ethereum + +1. [Come collegare i token al livello 2](/guides/how-to-use-a-bridge/) - Le transazioni di Ethereum sono troppo costose? Considera di spostare le soluzioni di ridimensionamento di Ethereum, dette Livelli 2. + +2. [Come scambiare i token](/guides/how-to-swap-tokens/) - Desideri scambiare i tuoi token per uno differente? Questa semplice guida ti mostrerà come farlo. + +## Abilità di pensiero decentralizzato + +Una volta ottenuto un portafoglio e utilizzate alcune delle sue funzionalità, puoi comprendere di più su Ethereum chiedendo, "_perché_ è importante?" Cosa rende prezioso il denaro se nessuno lo controlla? Cos'è la fiducia? Contribuisce alla libertà? Quali tipi di nuove strutture organizzative e di governance sono consentiti da Ethereum? Queste domande, e altre, sono approfondite liberamente in community come [Kernel](https://www.kernel.community/). diff --git a/src/content/translations/it/nft/index.md b/src/content/translations/it/nft/index.md index bb4d03ea0bb..9a267db83f7 100644 --- a/src/content/translations/it/nft/index.md +++ b/src/content/translations/it/nft/index.md @@ -7,79 +7,79 @@ emoji: ":frame_with_picture:" sidebarDepth: 3 image: ../../../../assets/infrastructure_transparent.png alt: Un logo Eth visualizzato tramite ologramma. -summaryPoint1: Un modo per rappresentare qualsiasi cosa unica come un asset basato su Ethereum. -summaryPoint2: Gli NFT stanno dando più potere che mai ai creatori di contenuti. -summaryPoint3: Basato sui contratti intelligenti sulla blockchain di Ethereum. +summaryPoint1: Un modo pe rappresentare qualsiasi cosa sia univoca, come una risorsa basata su Ethereum. +summaryPoint2: I NFT stanno dando ai creatori di contenuti più potere che mai. +summaryPoint3: Basati sui contratti intelligenti, sulla blockchain di Ethereum. --- -I NFT stanno avendo un successo travolgente nel mondo dell'arte digitale e degli oggetti da collezione. La vita di moltissimi artisti digitali sta cambiando grazie alle enormi vendite ad un nuovo pubblico di cripto-utenti. Anche diverse celebrità si stanno interessando al fenomeno, individuando nuove opportunità per agganciare i fan. Ma l'arte digitale è solo un modo per utilizzare i NFT. In realtà possono essere utilizzati per rappresentare la proprietà di qualsiasi bene unico, come un atto connesso a un oggetto nel mondo digitale o fisico. +I NFT, al momento, stanno prendendo d'assalto il mondo dell'arte e delle collezioni digitali. La vita di moltissimi artisti digitali sta cambiando, grazie alle enormi vendite a un nuovo cripto-pubblico. Anche svariate celebrità si stanno interessando al fenomeno, individuando nuove opportunità per connettersi con i fan. Ma l'arte digitale è soltanto uno dei modi per utilizzare i NFT. In realtà, sono utilizzabili per rappresentare la proprietà di qualsiasi risorsa univoca, come un atto per un oggetto, nel mondo digitale o fisico. -Se Andy Warhol fosse nato alla fine degli anni '90, probabilmente avrebbe coniato la sua Campbell's Soup come NFT. Prima o poi Nike inizi a vendere una serie di Jordan su Ethereum. E magari un giorno sarà possibile dimostrare il possesso della propria auto con un NFT. +Se Andy Warhol fosse nato alla fine degli anni 90, avrebbe probabilmente coniato le sue Campbell's Soup Cans, come NFT. È soltanto questione di tempo, prima che la Nike inizi a vendere una serie di Jordan su Ethereum. E, magari, un giorno sarà possibile dimostrare il possesso della propria auto con un NFT. ## Cos'è un NFT? {#what-are-nfts} -I NFT sono token che possiamo utilizzare per rappresentare la proprietà di oggetti unici. Ci consentono di tokenizzare cose come l'arte, gli oggetti da collezione e persino gli immobili. La proprietà di una risorsa è protetta dalla blockchain di Ethereum: nessuno può modificare il registro di proprietà o copiare/incollare un nuovo NFT in esistenza. +I NFT sono token utilizzabili per rappresentare la proprietà di oggetti univoci. Ci consentono di tokenizzare cose come l'arte, gli oggetti da collezione e persino gli immobili. La proprietà di una risorsa è protetta dalla blockchain di Ethereum: nessuno può modificare il registro di proprietà o copiare e incollare un nuovo NFT in esistenza. -NFT sta per Non-Fungible-Token (token non fungibile). Non fungibile è un termine economico che potremmo usare per descrivere cose come i mobili, un file musicale o un computer. Queste cose non sono intercambiabili per altri oggetti perché hanno proprietà uniche. +NFT sta per Non-Fungible Token, ossia Token Non Fungibile. Non fungibile è un termine economico utilizzabile per descrivere cose come mobilia, un file musicale, o il proprio computer. Queste cose non sono intercambiabili per altri articoli, perché hanno proprietà univoche. -Gli oggetti fungibili, invece, possono essere scambiati in quanto sono definiti dal loro valore piuttosto che dalle loro proprietà uniche. Per esempio, ETH o dollari sono fungibili perché 1 ETH / $1 USD è scambiabile con un altro ETH / $1 USD. +Gli oggetti fungibili, d'altra parte, sono scambiabili perché sono definiti dal proprio valore, piuttosto che dalle proprie proprietà univoche. Ad esempio, gli ETH o i dollari sono fungibili, perché 1 ETH o $1 USD, sono scambiabili per un altro 1 ETH o $1 USD. -## L'internet degli asset {#internet-of-assets} +## L'Internet delle risorse {#internet-of-assets} -Gli NFT ed Ethereum risolvono alcuni dei problemi che esistono oggi in Internet. Man mano che tutto diventa più digitale, aumenta l'esigenza di replicare le proprietà degli oggetti fisici, come la scarsità, l'unicità e la prova di proprietà. Per non parlare del fatto che spesso gli oggetti digitali funzionano solo nel contesto del loro prodotto. Ad esempio non è possibile rivendere un mp3 di iTunes dopo averlo acquistato e non è possibile scambiare punti fedeltà di una società con crediti di un'altra piattaforma, anche se ci fosse un mercato su cui farlo. +I NFT ed Ethereum risolvono alcuni dei problemi esistenti oggi su Internet. Man mano che tutto diventa più digitale, è necessario replicare le proprietà degli oggetti fisici, quali scarsità, unicità e prova di proprietà. Per non menzionare il fatto che gli oggetti digitali, spesso, funzionano soltanto nel contesto del proprio prodotto. Ad esempio, non puoi rivendere un mp3 acquistato di iTunes, né puoi scambiare i punti fedeltà di un'azienda per crediti di un'altra piattaforma, anche se esistesse un mercato per farlo. -Ecco come appare un Internet di NFT rispetto all'Internet che la maggior parte di noi usa oggi... +Questo è l'aspetto di un Internet di NFT, rispetto all'Internet utilizzato ad oggi da molti di noi... ### Un confronto {#nft-comparison} -| Internet di NFT | L'internet oggi | -| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| I NFT sono digitalmente unici, non esistono due NFT uguali. | Una copia di un file, come un .mp3 o .jpg, è uguale all'originale. | -| Ogni NFT deve avere un proprietario e questa è un'informazione di pubblico dominio, facilmente verificabile da chiunque. | I registri di proprietà degli oggetti digitali sono archiviati su server controllati da istituzioni - devi fidarti della loro parola. | -| I NFT sono compatibili con qualsiasi cosa costruita usando Ethereum. Un biglietto NFT per un evento può essere scambiato su qualunque mercato Ethereum contro un NFT completamente diverso. Potresti scambiare un'opera d'arte per un biglietto! | Le aziende con oggetti digitali devono costruire un'infrastruttura propria. Ad esempio, un'app che emette biglietti digitali per eventi dovrebbe costruire un'apposita piattaforma per lo scambio dei biglietti. | -| I creatori di contenuti possono vendere il loro lavoro ovunque e possono accedere ad un mercato globale. | I creatori si affidano all'infrastruttura e alla distribuzione delle piattaforme che utilizzano. Queste ultime sono spesso soggette a condizioni d'uso e a restrizioni geografiche. | -| I creatori possono conservare i diritti di proprietà sul proprio lavoro e rivendicare direttamente i diritti di rivendita. | Le piattaforme, come i servizi di streaming musicale, mantengono la maggior parte dei profitti derivanti dalle vendite. | -| Gli oggetti possono essere utilizzati in modi sorprendenti. Ad esempio, è possibile utilizzare un'opera d'arte digitale come garanzia per un prestito decentralizzato. | | +| Un Internet di NFT | L'internet di oggi | +| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| I NFT sono digitalmente univoci, non esistono due NFT uguali. | Una copia di un file, come un .mp3 o un .jpg, è uguale all'originale. | +| Ogni NFT deve avere un proprietario; tale informazione è di dominio pubblico ed è facilmente verificabile da chiunque. | I registri di proprietà degli articoli digitali sono memorizzati su server controllati dalle istituzioni; devi fidarti della loro parola. | +| I NFT sono compatibili con qualsiasi cosa si basi su Ethereum. Un biglietto NFT per un evento è scambiabile su qualsiasi mercato di Ethereum, per un NFT interamente differente. Potresti scambiare un'opera d'arte per un biglietto! | Le aziende con articoli digitali devono creare la propria infrastruttura. Ad esempio, un'app che emette biglietti digitali per degli eventi, dovrebbe creare la propria piattaforma di scambio di biglietti. | +| I creatori di contenuti possono vendere il proprio lavoro ovunque, e possono accedere a un mercato globale. | I creatori si affidano all'infrastruttura e la distribuzione delle piattaforme che utilizzano. Queste, sono spesso soggette a termini d'utilizzo e limitazioni geografiche. | +| I creatori possono conservare i diritti di proprietà sul proprio lavoro, rivendicando direttamente i diritti d'autore sulla rivendita. | Le piattaforme, come i servizi di streaming musicale, trattengono gran parte dei profitti dalle vendite. | +| Gli oggetti sono utilizzabili in modi sorprendenti. Ad esempio, è possibile utilizzare un'opera d'arte digitale come garanzia, per un prestito decentralizzato. | | ### Esempi di NFT {#nft-examples} -Il mondo degli NFT è relativamente nuovo. In teoria, rientra in questo mondo tutto ciò che è unico e che richiede una proprietà dimostrabile. Ecco alcuni esempi di NFT esistenti oggi, per farti un'idea: +Il mondo dei NFT è relativamente nuovo. In teoria, l'ambito peer i NFT è qualsiasi cosa sia univoca, che necessiti di proprietà dimostrabile. Ecco alcuni esempi di NFT esistenti oggi, per farti un'idea: -- [Un'opera d'arte digitale unica](https://foundation.app/artworks) -- [Una sneaker unica in una linea di moda limitata](https://www.metagrail.co/auctions/91cf83fb-3477-4155-aae8-6dcb9b853397) +- [Un'opera d'arte digitale univoca](https://foundation.app/artworks) +- [Una scarpa univoca, in una serie di moda limitata](https://www.metagrail.co/auctions/91cf83fb-3477-4155-aae8-6dcb9b853397) - [Un oggetto di gioco](https://market.decentraland.org/) - [Un saggio](https://zora.co/0x517bab7661C315C63C6465EEd1b4248e6f7FE183/145) -- [Un pezzo da collezione digitale](https://www.larvalabs.com/cryptopunks/details/1) +- [Un oggetto da collezione digitale](https://www.larvalabs.com/cryptopunks/details/1) - [Un nome di dominio](https://app.ens.domains/name/ethereum.eth) - [Un biglietto che ti dà accesso a un evento o un coupon](https://www.yellowheart.io/) -- [Acquista beni del mondo reale](https://www.tangible.store/) +- [Beni del mondo reale](https://www.tangible.store/) - [Immobili frazionalizzati](https://realt.co/) - [Certificati di laurea](https://www.degreecert.com/) -- [Royalty musicali tramite NFT](https://opulous.org/) -- [Move 2 earn](https://yeticoineth.com/about.html) -- [Identità digitale](https://photochromic.io/) +- [Diritti d'autore musicali, tramite NFT](https://opulous.org/) +- ["Move 2 earn"](https://yeticoineth.com/about.html) +- [Identità Digitale](https://photochromic.io/) ### Esempi di ethereum.org {#ethereum-org-examples} -Utilizziamo gli NFT per dare un riconoscimento ai nostri collaboratori e abbiamo anche un nostro nome di dominio NFT. +Utilizziamo i NFT per dare un riconoscimento ai nostri collaboratori, e abbiamo persino un nostro nome di dominio NFT. -#### POAP (Proof of attendance protocol) {#poaps} +#### POAP (Protocollo di prova di partecipazione) {#poaps} -Se contribuisci a ethereum.org, puoi rivendicare un NFT POAP. Si tratta di oggetti da collezione che dimostrano che hai partecipato ad un evento. In occasione di alcuni incontri nel mondo delle criptovalute sono stati usati i POAP come biglietto per i loro eventi. [Ulteriori informazioni sul contributo](/contributing/#poap). +Se contribuisci a ethereum.org, puoi rivendicare un NFT POAP. Si tratta di oggetti da collezione che provano la tua partecipazione a un evento. Alcuni incontri sulle criptovalute hanno utilizzato i POAP come una forma di biglietto a tali eventi. [Di più su come contribuire](/contributing/#poap). -![ethereum.org POAP](../../../../assets/use-cases/poap.png) +![POAP di ethereum.org](../../../../assets/use-cases/poap.png) #### ethereum.eth {#ethereum-dot-eth} -Questo sito web ha un nome di dominio alternativo alimentato da NFT, **ethereum.eth**. Il nostro indirizzo `.org` è gestito centralmente da un fornitore di sistema di nomi di dominio (DNS), mentre ethereum`.eth` è registrato su Ethereum tramite l'Ethereum Name Service (ENS). Ed è posseduto e gestito da noi. [Consulta il nostro record ENS](https://app.ens.domains/name/ethereum.eth) +Questo sito web ha un nome di dominio alternativo alimentato da NFT, **ethereum.eth**. Il nostro indirizzo `.org` è gestito centralmente da un fornitore di sistema di nomi di dominio (DNS), mentre ethereum`.eth` è registrato su Ethereum tramite il Servizio del Nome di Ethereum (ENS). Ed è posseduto e gestito da noi. [Consulta il nostro registro ENS](https://app.ens.domains/name/ethereum.eth) -[Maggiori informazioni sull'ENS](https://app.ens.domains) +[Di più sull'ENS](https://app.ens.domains) ## Come funzionano i NFT? {#how-nfts-work} -Gli NFT sono diversi dai token ERC-20, come DAI o LINK, in quanto ogni singolo token è completamente unico e non divisibile. Gli NFT danno la possibilità di assegnare o rivendicare la proprietà di qualsiasi dato unico digitale, monitorabile utilizzando la blockchain di Ethereum come un registro pubblico. Un NFT è coniato da oggetti digitali come una rappresentazione di attivi digitali o non digitali. Ad esempio, un NFT potrebbe rappresentare: +I NFT sono diversi dai token ERC-20, quali DAI o LINK, poiché ogni singolo token è completamente unico e non divisibile. I NFT permettono di assegnare o rivendicare la proprietà di qualsiasi dato digitale univoco, tracciabile utilizzando la blockchain di Ethereum come un registro pubblico. Un NFT è coniato dagli oggetti digitali come una rappresentazione di risorse digitali o non digitali. Ad esempio, un NFT potrebbe rappresentare: - Arte digitale: - GIF @@ -87,269 +87,270 @@ Gli NFT sono diversi dai token ERC-20, come DAI o LINK, in quanto ogni singolo t - Musica - Video - Oggetti reali: - - Atti di possesso di una macchina + - Atti di possesso di un'auto - Biglietti per un evento del mondo reale - Fatture tokenizzate - Documenti legali - Firme - Molte altre opzioni con cui dare libero sfogo alla creatività! -La proprietà dei NFT è gestita tramite l'ID e i metadati univoci che nessun altro token può replicare. I NFT sono coniati tramite i contratti intelligenti, che assegnano la proprietà e gestiscono la trasferibilità dei NFT. Quando qualcuno crea o conia un NFT, esegue il codice memorizzato nei contratti intelligenti conformi a diversi standard, come l'[ERC-721](/developers/docs/standards/tokens/erc-721/). Queste informazioni sono aggiunte alla blockchain dov'è gestito il NFT. Il processo di conio, da un livello elevato, include i seguenti passaggi: +La proprietà dei NFT è gestita tramite l'ID univoco e i metadati, non replicabili da alcun altro token. I NFT sono coniati tramite i contratti intelligenti, che assegnano la proprietà e gestiscono la trasferibilità dei NFT. Quando qualcuno crea o conia un NFT, esegue del codice memorizzato nei contratti intelligenti e conforme a svariati standard, come l'[ERC-721](/developers/docs/standards/tokens/erc-721/). Queste informazioni sono aggiunte alla blockchain, dove i NFT sono gestiti. Il processo di conio, in linea generale, include i seguenti passaggi: - Creazione di un nuovo blocco - Convalida delle informazioni - Registrazione delle informazioni nella blockchain -Gli NFT hanno alcune proprietà speciali: +I NFT hanno delle proprietà speciali: -- Ogni token coniato ha un identificativo unico, che è direttamente collegato a un indirizzo Ethereum. -- Non sono direttamente intercambiabili con altri token 1:1. Ad esempio, 1 ETH è esattamente uguale a un altro ETH. Non è invece così per i NFT. -- Ogni token ha un proprietario e l'informazione è facilmente verificabile. -- Sono disponibili su Ethereum e possono essere acquistati e venduti su qualsiasi mercato NFT basato su Ethereum. +- Ogni token coniato ha un identificativo univoco, collegato direttamente a un indirizzo di Ethereum. +- Non sono direttamente intercambiabili con altri token, in un rapporto 1 a 1. Ad esempio, 1 ETH è esattamente uguale a un altro ETH. Questo non è il caso con i NFT. +- Ogni token ha un proprietario e, tale informazione, è facilmente verificabile. +- Risiedono su Ethereum e sono acquistabili e vendibili su qualsiasi mercato di NFT basato su Ethereum. In altre parole, se _possiedi_ un NFT: - Puoi facilmente dimostrare di possederlo. - - Dimostrare che possiedi un NFT è molto simile a provare di possedere ETH nel tuo conto. - - Ad esempio, se acquisti un NFT la proprietà del token univoco viene trasferita al tuo portafoglio tramite il tuo indirizzo pubblico. + - Dimostrare che possiedi un NFT è molto simile a dimostrare di possedere ETH nel tuo conto. + - Ad esempio, se acquisti un NFT, e la proprietà del token univoco è trasferita al tuo portafoglio tramite il tuo indirizzo pubblico. - Il token dimostra che la tua copia del file digitale è l'originale. - La tua chiave privata è la prova che dimostra la proprietà dell'originale. - - La chiave pubblica del creatore di contenuti funge da certificato di autenticità per quel particolare artefatto digitale. - - La chiave pubblica del creatore è essenzialmente una parte permanente della storia del token. Essa può dimostrare che il token che hai in mano è stato creato da un particolare individuo, contribuendo così al suo valore di mercato (contro la contraffazione). - - Un altro modo per dimostrare il possesso dell'NFT consiste nel firmare i messaggi per provare il possesso della chiave privata dietro l'indirizzo. - - Come accennato in precedenza, la tua chiave privata è la prova di proprietà dell'originale. Questo ci dice che le chiavi private dietro quell'indirizzo controllano l'NFT. - - Un messaggio firmato può essere utilizzato come prova del possesso delle chiavi private senza rivelarle a nessuno, dimostrando così al contempo il possesso dell'NFT! + - La chiave pubblica del creatore del contenuto serve da certificato dell'autenticità per quell'artefatto digitale in particolare. + - La chiave pubblica del creatore è essenzialmente una parte permanente della storia del token. Può dimostrare che il token che possiedi è stato creato da un particolare individuo, contribuendo al suo valore di mercato (rispetto a un falso). + - Un altro modo di pensare alla dimostrazione del possesso del NFT, è firmare i messaggi per dimostrare di possedere la chiave privata dietro all'indirizzo. + - Come accennato in precedenza, la tua chiave privata è la prova di proprietà dell'originale. Questo ci dice che le chiavi private dietro quell'indirizzo controllano il NFT. + - Un messaggio firmato è utilizzabile come prova del possesso delle tue chiavi private, senza rivelarle a nessuno e, dunque, dimostrando anche di possedere il NFT! - Nessuno può manipolarlo in alcun modo. -- Puoi venderlo e in alcuni casi questo farà guadagnare al creatore originale le royalty di rivendita. -- Oppure, puoi tenerlo per sempre e dormire sonni tranquilli sapendo che il tuo asset è protetto dal tuo portafoglio su Ethereum. +- Puoi venderlo e in alcuni casi questo farà guadagnare al creatore originale i diritti d'autore sulla rivendita. +- Oppure, puoi conservarlo per sempre, dormendo sonni tranquilli, consapevole del fatto che la tua risorsa è protetta dal tuo portafoglio, su Ethereum. Se invece _crei_ un NFT: - Puoi facilmente dimostrare di essere il creatore. - Ne determini la scarsità. -- Puoi guadagnare royalties ogni volta che viene venduto. -- Puoi venderlo su qualsiasi mercato di NFT o peer-to-peer. Non sei vincolato a una piattaforma specifica e non hai bisogno di intermediari. +- Puoi guadagnare royalty ogni volta che viene venduto. +- Puoi venderlo su qualsiasi mercato di NFT o tra pari. Non sei vincolato ad alcuna piattaforma e non necessiti di intermediari. ### Scarsità {#scarcity} -Il creatore di un NFT decide la scarsità del proprio attivo. +Il creatore di un NFT decide la scarsità della propria risorsa. -Prendiamo ad esempio un biglietto per un evento sportivo. Proprio come l'organizzatore di un evento può scegliere quanti biglietti vendere, il creatore di un NFT può decidere quante repliche esistono. A volte queste sono repliche esatte, come 5000 biglietti di ingresso generici. A volte ne vengono coniati diversi molto simili, ma ognuno leggermente diverso, come nel caso dei biglietti con i posti assegnati. Oppure, può capitare che il creatore voglia creare un NFT in cui viene coniata una sola unità come oggetto da collezione raro e speciale. +Ad esempio, consideriamo un biglietto per un evento sportivo. Proprio come soltanto l'organizzatore di un evento può scegliere quanti biglietti vendere, il creatore di un NFT può decidere quante repliche ne esisteranno. Talvolta queste sono repliche esatte, come 5000 biglietti generici di ingresso. Altre volte, ne sono coniati svariati di molto simili, ma ognuno lievemente differente, come un biglietto con un posto assegnato. In un altro caso, il creatore potrebbe voler coniare un singolo NFT, come un oggetto da collezione raro e speciale. -In questi casi, ogni NFT ha comunque un identificativo univoco (come un codice a barre su un biglietto tradizionale), con un solo proprietario. La scarsità prevista dell'NFT è importante e dipende dal creatore. Un creatore potrebbe voler rendere ogni NFT completamente unico per creare scarsità o avere motivi validi per produrre diverse migliaia di repliche. Ricorda: queste informazioni sono tutte pubbliche. +In questi casi, ogni NFT avrebbe comunque un identificativo univoco (come un codice a barre su un "biglietto" tradizionale), con soltanto un proprietario. La scarsità prevista del NFT conta, e dipende dal creatore. Un creatore potrebbe prevedere di rendere ogni NFT completamente univoco, per generare scarsità, o avere motivazioni per produrne svariate migliaia di repliche. Ricorda: tutte queste informazioni sono pubbliche. -### Royalties {#royalties} +### Royalty {#royalties} -Alcuni NFT pagano automaticamente i diritti d'autore ai loro creatori quando vengono venduti. Si tratta di un concetto ancora in evoluzione, ma è uno dei più potenti. I proprietari originali di [EulerBeats Originals](https://eulerbeats.com/) guadagnano un 8% di diritti d'autore ogni volta che l'NFT viene rivenduto. Alcune piattaforme, come [Foundation](https://foundation.app) e [Zora](https://zora.co/), supportano i diritti d'autore per i loro artisti. +Alcuni NFT pagheranno automaticamente le royalty ai propri creatori, alla vendita. Questo è un concetto ancora in evoluzione, ma è uno dei più potenti. I proprietari originali di [EulerBeats Originals](https://eulerbeats.com/) guadagnano un 8% di diritti d'autore ogni volta che l'NFT viene rivenduto. Alcune piattaforme, come [Foundation](https://foundation.app) e [Zora](https://zora.co/), supportano i diritti d'autore per i propri artisti. -Il sistema è completamente automatico, quindi i creatori possono mettersi comodi e guadagnare sui diritti d'autore mentre il loro lavoro viene venduto da persona a persona. Al momento, i processi connessi ai diritti d'autore sono estremamente manuali e poco precisi, infatti molti creatori non ricevono quello che meritano. Se il tuo NFT è stato programmato con un diritto d'autore, non perderai mai. +Ciò è completamente automatico, così che i creatori possano mettersi comodi e guadagnare le royalty, mentre il loro lavoro viene venduto, da persona a persona. Al momento, comprendere le royalty è un procedimento manuale e privo di precisione; molti creatori non ricevono quanto meritano. Se il tuo NFT è stato programmato con un diritto d'autore, non andrai mai in perdita. -## Per cosa vengono utilizzati i NFT? {#nft-use-cases} +## Per cosa sono utilizzati i NFT? {#nft-use-cases} -Ecco maggiori informazioni su alcuni dei casi d'uso e delle visioni più sviluppate per gli NFT su Ethereum. +Ecco ulteriori informazioni su alcuni dei casi d'uso e visioni più sviluppati per i NFT, su Ethereum. - [Contenuti digitali](#nfts-for-creators) - [Oggetti di gioco](#nft-gaming) - [Nomi di dominio](#nft-domains) - [Oggetti fisici](#nft-physical-items) -- [Investimenti e garanzie reali](#nfts-and-defi) -- [Ticket di accesso](#tokengating) +- [Investimenti e garanzie](#nfts-and-defi) +- [Tokengating](#tokengating) ### Massimizzare i guadagni per i creatori {#nfts-for-creators} -Il più ampio utilizzo degli NFT oggi è nel campo dei contenuti digitali. Questo perché oggi come oggi si tratta di un settore problematico. I creatori di contenuti vedono i loro profitti e i potenziali guadagni inghiottiti dalle piattaforme. +Oggi, l'utilizzo maggiore dei NFT, è nel campo dei contenuti digitali. Questo perché, oggi, l'industria è problematica. I creatori di contenuti vedono i propri profitti e potenziali guadagni, venir inghiottiti dalle piattaforme. -Un artista che pubblica un'opera su un social network genera denaro per la piattaforma che vende annunci ai follower degli artisti. In cambio ottiene l'esposizione, ma l'esposizione non paga le bollette. +Un artista che pubblica un'opera su un social, genera denaro per la piattaforma, che vende annunci ai seguaci degli artisti. In cambio, ottengono visibilità ma, questa, non paga le bollette. -Gli NFT alimentano una nuova economia creativa in cui i creatori non consegnano la proprietà dei loro contenuti alle piattaforme che utilizzano per pubblicizzarli. La proprietà è incorporata nel contenuto stesso. +I NFT alimentano una nuova economia creativa, dove i creatori non consegnano la proprietà dei propri contenuti alle piattaforme che utilizzano per pubblicizzarli. La proprietà è incorporata nel contenuto stesso. -Quando vendono i loro contenuti, i fondi vanno direttamente a loro. Se il nuovo proprietario poi vende gli NFT, il creatore originale può addirittura ricevere i diritti d'autore automaticamente. Ciò è garantito ogni volta che viene venduto perché l'indirizzo del creatore fa parte dei metadati del token, che non possono essere modificati. +Quando vendono i propri contenuti, i fondi vanno direttamente a loro. Poi, se il nuovo proprietario vende il NFT, il creatore originale può persino ricevere automaticamente le royalty. Ciò è garantito ogni volta che viene venduto, perché l'indirizzo del creatore fa parte dei metadati del token; metadati che non possono essere modificati. -
Esplora, acquista o crea il tuo NFT collegato a opere d'arte/oggetti da collezione...
+
Esplora, acquista o crea opere d'arte/oggetti da collezione NFT...
- Esplora i NFT connessi a opere d'arte + Esplora l'arte NFT #### Il problema del copia/incolla {#nfts-copy-paste} -Gli oppositori spesso tirano in ballo il fatto che gli NFT "sono stupidi", di solito aggiungendo un'immagine di sé mentre eseguono lo screenshot di un'opera d'arte NFT. "Guarda, ora ho quell'immagine gratis!", dicono compiaciuti. +Gli scettici, spesso, tirano in ballo il fatto che i NFT "siano stupidi", solitamente aggiungendo un'immagine di sé, mentre eseguono lo screenshot di un'opera d'arte NFT. "Guardate, ora ho quell'immagine gratis!", dicono compiaciuti. -Beh, sì. Ma cercare su Google un'immagine della Guernica di Picasso ti rende forse il nuovo orgoglioso proprietario di un pezzo di storia dell'arte del valore di diversi milioni di dollari? +Beh, sì. Ma cercare su Google un'immagine della Guernica di Picasso, vi rende gli orgogliosi proprietari di un'opera di storia dell'arte del valore di diversi milioni di euro? -In definitiva, possedere l'oggetto reale ha tanto valore quanto gliene viene attribuito dal mercato. Più un contenuto viene acquisito mediante screenshot, condiviso e generalmente utilizzato, più valore acquisisce. +In definitiva, possedere l'oggetto reale ha tanto valore quanto gliene è attribuito dal mercato. Più un contenuto è acquisito mediante screenshot, condiviso e, in generale, utilizzato, più valore acquisisce. -Possedere l'oggetto reale verificabile avrà sempre più valore che non possederlo. +Possedere l'oggetto verificabilmente reale, avrà sempre molto più valore che non possederlo. -### Aumentare il potenziale di gioco {#nft-gaming} +### Incrementare il potenziale dei videogiochi {#nft-gaming} -Gli NFT hanno destato un notevole interesse tra gli sviluppatori di giochi. Gli NFT possono fornire record di proprietà per gli oggetti di gioco, alimentare le economie dei videogiochi e portare una serie di vantaggi ai giocatori. +I NFT hanno sviluppato notevole interesse da parte degli sviluppatori di videogiochi. I NFT possono fornire registri di proprietà per oggetti di gioco, alimentare le economie di gioco e comportare una serie di benefici per i giocatori. -In molti videogiochi normali è possibile acquistare oggetti da utilizzare nel gioco stesso. Ma se quell'oggetto fosse un NFT, potresti recuperare i tuoi soldi vendendolo quando hai finito di giocare. Potresti persino realizzare un profitto se quell'oggetto diventa più desiderabile. +In molti videogiochi regolari, puoi acquistare oggetti da utilizzare nel gioco stesso. Ma se quell'oggetto fosse stato un NFT, avresti potuto recuperare il tuo denaro, rivendendolo una volta finito di giocare. Potresti persino realizzare un profitto, se quell'oggetto diventa più desiderabile. -Gli sviluppatori di giochi (in veste di emittenti di NFT) potrebbero guadagnare sui diritti d'autore ogni volta che un oggetto viene rivenduto sul mercato aperto. Ciò crea un modello aziendale più vantaggioso per entrambe le parti, in cui sia i giocatori che gli sviluppatori guadagnano dal mercato secondario degli NFT. +Per gli sviluppatori di gioco, in veste di emittenti di NFT, potrebbero guadagnare una royalty a ogni rivendita di un oggetto, sul mercato aperto. Ciò crea un modello aziendale più vantaggioso per ambe le parti, dove sia i giocatori che gli sviluppatori guadagnano dal mercato secondario dei NFT. -Questo significa anche che se un gioco non è più mantenuto dagli sviluppatori, gli oggetti che hai raccolto rimangono tuoi. +Inoltre, ciò significa che se un gioco non è più mantenuto dagli sviluppatori, gli oggetti collezionati, rimangono tuoi. -Alla fine, gli oggetti che sfrutti per il gioco possono sopravvivere al gioco stesso. Anche se un gioco non viene più mantenuto, i tuoi oggetti saranno sempre sotto il tuo controllo. Ciò significa che gli oggetti di gioco diventano cimeli digitali e hanno un valore al di fuori del gioco. +Infine, gli oggetti che sfrutti nel gioco, possono vivere più dei giochi stessi. Anche se un gioco non è più mantenuto, i tuoi oggetti resteranno sempre sotto il tuo controllo. Ciò significa che, questi, diventano cimeli digitali e hanno un valore esterno al gioco. -Decentraland, un gioco di realtà virtuale, consente persino di acquistare NFT che rappresentano appezzamenti di terreno virtuali, che puoi utilizzare come meglio credi. +Decentraland, un gioco in realtà virtuale, ti consente persino di acquistare NFT rappresentanti appezzamenti di terreno virtuali, utilizzabili come meglio credi. -
Scopri i giochi Ethereum, alimentati da NFT...
+
Scopri i giochi di Ethereum, alimentati dai NFT...
- Esplora i giochi basati su NFT + Esplora i giochi NFT -### Rendere gli indirizzi di Ethereum più facili da ricordare {#nft-domains} +### Rendere gli indirizzi di Ethereum più memorizzabili {#nft-domains} -L'Ethereum Name Service utilizza gli NFT per associare il tuo indirizzo Ethereum a un nome più facile da ricordare, come `mywallet.eth`. Ciò significa che potresti chiedere a qualcuno di inviarti ETH tramite `mywallet.eth` anziché `0x123456789.....`. +Il Servizio del Nome di Ethereum utilizza i NFT per fornire il tuo indirizzo di Ethereum, con un nome più facile da ricordare, come `mywallet.eth`. Ciò significa che potresti chiedere a qualcuno di inviarti degli ETH tramite `mywallet.eth`, piuttosto che tramite `0x123456789.....`. -Il principio è simile a quello di un nome di dominio di un sito web, che rende un indirizzo IP più facile da ricordare. Proprio come i domini, i nomi ENS hanno un valore, di solito in base alla lunghezza e alla pertinenza. Con ENS non è necessario un registro di dominio per facilitare il trasferimento della proprietà. Invece, è possibile scambiare i nomi ENS su un mercato NFT. +Ciò funziona similmente al nome di dominio di un sito web, che rende un indirizzo IP più memorizzabile. E come per i domini, i nomi dell'ENS hanno un valore, solitamente basato sulla lunghezza e la rilevanza. Con l'ENS, non è necessario un registro del dominio per facilitare il trasferimento della proprietà. Invece, puoi scambiare i tuoi nomi ENS su un mercato di NFT. Il tuo nome ENS può: - Ricevere criptovalute e altri NFT. -- Puntare su un sito web decentralizzato, come [ethereum.eth](https://ethereum.eth.link). [Ulteriori informazioni sulla decentralizzazione del tuo sito web](https://docs.ipfs.io/how-to/websites-on-ipfs/link-a-domain/#domain-name-service-dns) -- Memorizzare qualsiasi informazione arbitraria, comprese le informazioni sul profilo come indirizzi e-mail e handle di Twitter. +- Puntare a un sito web decentralizzato, come [ethereum.eth](https://ethereum.eth.link). [Di più sulla decentralizzazione del tuo sito web](https://docs.ipfs.io/how-to/websites-on-ipfs/link-a-domain/#domain-name-service-dns) +- Memorizzare qualsiasi informazione arbitraria, incluse informazioni del profilo, quali indirizzi email e pseudonimi di Twitter. ### Oggetti fisici {#nft-physical-items} -La tokenizzazione degli oggetti fisici non è ancora così sviluppata come le loro controparti digitali. Ci sono però molti progetti che esplorano la tokenizzazione di beni immobili, oggetti di moda unici e altro ancora. +La tokenizzazione degli oggetti fisici non è ancora tanto sviluppata quanto le controparti digitali. Esistono però numerosi progetti che esplorano la tokenizzazione degli immobili, degli articoli di moda unici e altro ancora. -Poiché gli NFT sono essenzialmente atti, un giorno potresti acquistare un'automobile o una casa usando ETH e ricevere in cambio l'atto sotto forma di NFT (nella stessa transazione). Man mano che il mondo diventa sempre più high-tech, non è difficile immaginare una situazione in cui il tuo portafoglio Ethereum diventa la chiave per aprire la tua automobile o la tua casa, ad esempio sbloccando la porta con la prova crittografica della proprietà. +Poiché i NFT sono essenzialmente atti, un giorno potresti acquistare un'auto o una casa utilizzando gli ETH, e ricevere l'atto come un NFT in cambio (nella stessa transazione). All'incrementare dell'alta tecnologia, non è difficile immaginare un mondo in cui il tuo portafoglio di Ethereum diventa la chiave per aprire la tua auto o la tua casa; ad esempio, sbloccando la tua serratura tramite una prova crittografica di proprietà. -Con beni preziosi come automobili e proprietà rappresentabili su Ethereum, è possibile utilizzare gli NFT come garanzia reale nei prestiti decentralizzati. Ciò è particolarmente utile se non sei ricco in termini di denaro o criptovalute ma possiedi oggetti di valore fisici. [Maggiori informazioni sulla DeFi](/defi/) +Con beni preziosi, quali auto e proprietà, rappresentabili su Ethereum, puoi utilizzare i NFT come garanzia nei prestiti decentralizzati. Ciò è particolarmente utile se non sei ricco in termini di contanti o criptovalute, ma possiedi oggetti fisici di valore. [Di più sulla DeFi](/defi/) ### I NFT e la DeFi {#nfts-and-defi} -Il mondo degli NFT e la [finanza decentralizzata (DeFi)](/defi/) stanno iniziando a interagire in diversi modi interessanti. +Il mondo dei NFT e della [finanza decentralizzata (DeFi)](/defi/), stanno iniziando a interagire in svariati, interessanti modi. #### Prestiti garantiti dai NFT {#nft-backed-loans} -Ci sono applicazioni DeFi che consentono di prendere in prestito denaro utilizzando garanzie reali. Ad esempio, dai in garanzia 10 ETH in modo da poter prendere in prestito 5.000 DAI ([una stablecoin](/stablecoins/)). In questo modo si assicura che il mutuante venga rimborsato: se il mutuatario non rimborsa i DAI, la garanzia reale viene inviata al mutuante. Tuttavia, non tutti hanno abbastanza criptoattivi da usare come garanzia. +Esistono delle applicazioni della DeFi che ti consentono di prendere in prestito del denaro, utilizzando delle garanzie. Ad esempio, dai 10 ETH in garanzia, così da poter prendere in prestito 5000 DAI ([una Stablecoin](/stablecoins/)). Ciò assicura che il creditore sia rimborsato: se il debitore non ripaga i DAI, la garanzia è inviata al creditore. Tuttavia, non tutti possiedono abbastanza criptovalute da utilizzare come garanzia. -Una serie di progetti sta iniziando ad esplorare l'utilizzo degli NFT come garanzia reale. Immagina di aver comprato un raro NFT CryptoPunk in passato. Ai prezzi odierni, può valere anche migliaia di dollari. Mettendo questo attivo come garanzia reale, puoi accedere ad un prestito con la stessa serie di regole. Se non ripaghi il DAI, il tuo CryptoPunk verrà inviato al mutuante a titolo di garanzia reale. Questo sistema potrebbe alla fine funzionare con qualsiasi cosa tokenizzata sotto forma di NFT. +Invece, dei progetti stanno iniziando a esplorare l'utilizzo dei NFT come garanzie. Immagina di aver comprato un raro NFT CryptoPunk; ai prezzi odierni, possono valere anche migliaia di dollari. Mettendolo come garanzia, puoi accedere a un prestito con la stessa serie di regole. Se non ripaghi i DAI, il tuo CryptoPunk sarà inviato al creditore come garanzia. Infine, ciò potrebbe funzionare con qualsiasi cosa tu tokenizzi, sotto forma di NFT. -E questo non è difficile su Ethereum, perché entrambi i mondi (NFT e DeFi) condividono la stessa infrastruttura. +E, questo, non è difficile su Ethereum, poiché entrambi i mondi (NFT e DeFi), condividono la stessa infrastruttura. -#### Proprietà frazionata {#fractional-ownership} +#### Multiproprietà {#fractional-ownership} -I creatori di NFT possono anche creare "azioni" per il loro NFT. Così facendo si offre agli investitori e ai fan l'opportunità di possedere parte di un NFT senza doverlo comprare interamente, oltre ad accrescere le opportunità per coniatori e collezionisti di NFT. +I creatori di NFT possono anche creare "azioni" per i propri NFT. Questo dà a investitori e fan, l'opportunità di possedere una parte di un NFT, senza doverlo acquistare per intero. Questo accresce persino di più le opportunità per i coniatori e collezionisti di NFT. -- I NFT frazionati possono essere scambiati su [scambi decentralizzati](/defi/#dex) come Uniswap, non solo sui [mercati dei NFT](/dapps?category=collectibles). Ciò significa più acquirenti e venditori. +- I NFT frazionati sono scambiabili sulle [DEX](/defi/#dex) come Uniswap, non soltanto sui [mercati di NFT](/dapps?category=collectibles). Ciò significa più acquirenti e venditori. - Il prezzo complessivo di un NFT può essere definito dal prezzo delle sue frazioni. - Hai più di un'opportunità di possedere e trarre profitto dagli oggetti a cui tieni. È più difficile avere un prezzo per il possesso di NFT. -Questa idea è ancora sperimentale, ma puoi scoprire maggiori informazioni sulla proprietà frazionata degli NFT nei seguenti scambi: +Quest'idea è ancora sperimentale, ma puoi imparare di più sulla multiproprietà dei NFT, sulle seguenti piattaforme di scambio: - [NIFTEX](https://landing.niftex.com/) - [NFTX](https://gallery.nftx.org/) -In teoria, questo sbloccherebbe la possibilità di fare cose come possedere un'opera di Picasso. Diventeresti un azionista di un NFT collegato a un'opera di Picasso, il che significa che avresti voce in capitolo su aspetti come la ripartizione degli introiti. È molto probabile che un giorno non molto lontano, possedere una frazione di un NFT ti farà entrare in un'organizzazione autonoma decentralizzata (DAO) per la gestione di quell'attivo. +In teoria, questo sbloccherebbe la possibilità di fare cose come possedere parte di un'opera di Picasso. Diverresti un azionista in un NFT di Picasso, a significare che avresti voce in capitolo su cose come la ripartizione degli introiti. È molto probabile che, presto, possedere la frazione di un NFT consentirà l'accesso a un'organizzazione autonoma decentralizzata (DAO), per la gestione di tale risorsa. -Si tratta di organizzazioni alimentate da Ethereum che consentono a sconosciuti, come gli azionisti globali di un attivo, di coordinarsi in modo sicuro senza doversi necessariamente fidare degli altri. Questo perché non un solo centesimo può essere speso senza l'approvazione del gruppo. +Queste, sono organizzazioni alimentate da Ethereum che consentono a sconosciuti, come azionisti globali di una risorsa, di coordinarsi in sicurezza, senza doversi necessariamente fidare di altre persone. Questo perché nemmeno un centesimo può essere speso senza l'approvazione del gruppo. -Come abbiamo detto, si tratta di uno spazio emergente. NFT, DAO e token frazionati si stanno sviluppando a ritmi diversi. Ma tutte le loro infrastrutture esistono e possono lavorare insieme facilmente perché parlano tutte la stessa lingua: Ethereum. Ti suggeriamo quindi di tenere d'occhio questo spazio. +Come menzionato, si tratta di spazi emergenti. NFT, DAO e token frazionati si stanno tutti sviluppando a ritmi differenti. Ma tutte le loro infrastrutture esistono e possono cooperare facilmente, perché parlano tutte la stessa lingua: Ethereum. Quindi, ti suggeriamo di tenerle d'occhio. [Maggiori informazioni sulle DAO](/dao/) ### Certificati d'autenticità {#certificates} -Le aziende che offrono finti certificati di laurea sono a quanto pare un'industria da un miliardo di dollari, che gli NFT possono aiutare a combattere. Gli NFT possono essere un modo sicuro e rapido per verificare le credenziali di laurea di qualcuno. +Le aziende che offrono certificati di laurea falsi, sono a quanto pare un'industria da miliardi di euro, che i NFT possono aiutare a combattere. I NFT possono essere un metodo sicuro e rapido per verificare le credenziali di laurea di qualcuno. -[In Sud Corea, un'università sta già emettendo certificati di laurea in forma di NFT](https://forkast.news/headlines/south-korea-nfts-graduates-hoseo/), nella speranza che gli NFT miglioreranno l'accesso ai servizi amministrativi e impediranno la contraffazione o alterazione delle lauree. [Anche la Trinity Business School (TBS) in Irlanda prevede di offrire gli NFT a partire dal 2023](https://trinitynews.ie/2022/04/business-school-to-offer-degree-nfts/). +[In Corea del Sud, un'università sta già emettendo certificati di laurea sotto forma di NFT](https://forkast.news/headlines/south-korea-nfts-graduates-hoseo/), nella speranza che i NFT miglioreranno l'accesso ai servizi amministrativi, impedendo la contraffazione o alterazione delle stesse. [Anche la Trinity Business School (TBS), in Irlanda, sta pianificando di offrire NFT, a partire dal 2023](https://trinitynews.ie/2022/04/business-school-to-offer-degree-nfts/). ### Ticket di accesso {#tokengating} -Il ticket di accesso tramite NFT (in gergo “Tokengating”) è un modo per limitare l'accesso a qualcosa, sfruttando gli NFT come un modalità di accesso. Questi elementi possono variare enormemente a seconda della piattaforma, ma esempi comuni sono i contenuti riservati, i server di chat privati e, nel mondo dell'e-commerce, i prodotti esclusivi. +Il tokengating, o ticket d'accesso, è un metodo per limitare l'accesso a qualcosa, sfruttando i NFT per sbloccare tale accesso. Questi, possono variare enormemente a seconda della piattaforma, ma sono esempi comuni i contenuti riservati, i server di chat privati e, nel mondo dell'e-commeerce, i prodotti esclusivi. -Una piattaforma che fa tokengating chiederà solitamente all’utente di collegare il suo portafoglio per dimostrare il possesso dell'NFT richiesto. Se si dispone dell'NFT richiesto, si otterrà l'accesso. In caso contrario, l'ingresso rimarrà chiuso. Gli NFT sono un ottimo strumento per questo compito, perché sono unici: non si può fingere di possederli per ottenere l'accesso. +Una piattaforma che fa "tokengating", ti chiederà tipicamente di connettere il tuo portafoglio per dimostrare che tu possieda il NFT necessario. Se disponi del NFT richiesto, otterrai l'accesso. Altrimenti, l'accesso rimarrà negato. I NFT sono un ottimo metodo per farlo per via della loro unicità: non puoi falsificarne la proprietà per ottenere l'accesso. -Poiché gli NFT sono su Ethereum, possono essere utilizzati per sbloccare l'accesso tramite Ethereum su qualsiasi piattaforma che li implementa. Un singolo NFT che possiedi può sbloccare contenuti riservati, server di chat privati e prodotti esclusivi su siti web e applicazioni completamente diversi. +Poiché i NFT sono su Ethereum, sono utilizzabili per sbloccare i tokengate di Ethereum su qualsiasi piattaforma li implementi. Un singolo NFT che possiedi potrebbe sbloccare contenuti limitati, server di chat private e prodotti esclusivi, su siti web e applicazioni completamente differenti. -Se il conio e la distribuzione di NFT riguardano la generazione o la digitalizzazione di una community, il tokengating un modo per coltivarla. Con questo strumento gli NFT trovano impiego più che altro come strumento per l'adesione o la fidelizzazione, e un ottimo modo per dare in modo affidabile i benefici che ne derivano. +Se coniare e distribuire NFT riguarda la generazione o digitalizzazione della community, il tokengating è un modo per coltivarla. Così, i NFT sono più utilizzati come strumenti per adesione o fedelizzazione; nonché come un ottimo modo per consegnare in modo affidabile le ricompense che ne derivano. #### Esempi -- [Collab.land](https://collab.land/) da accesso a delle chat sui server Discord o gruppi Telegram -- [Unlock protocol](https://unlock-protocol.com/) è un protocollo per la creazione di NFT per il tokengating -- [Shopify](https://help.shopify.com/en/manual/products/digital-service-product/nfts) ha un serie crescente di applicazioni che consentono ai commercianti di limitare l'accesso ai prodotti e sconti usando il tokengating +- [Collab.land](https://collab.land/) dà accesso a delle chat su server Discord o gruppi Telegram +- Il [protocollo Unlock](https://unlock-protocol.com/) è un protocollo per il tokengating +- [Shopify](https://help.shopify.com/en/manual/products/digital-service-product/nfts) include sempre più app che consentono ai commercianti di limitare l'accesso ai prodotti e agli sconti -## Ethereum e NFT {#ethereum-and-nfts} +## Ethereum e i NFT {#ethereum-and-nfts} -Ethereum rende possibile il funzionamento degli NFT per vari motivi: +Ethereum rende possibile il funzionamento dei NFT per numerosi motivi: -- La cronologia delle transazioni e i metadati dei token sono verificabili pubblicamente: è semplice dimostrare la storia della proprietà. -- Una volta che una transazione è confermata, è quasi impossibile manipolare quei dati per "rubare" la proprietà. -- Lo scambio di NFT può avvenire peer-to-peer senza bisogno di piattaforme che prelevano buona parte dei compensi. -- Tutti i prodotti Ethereum condividono lo stesso "backend". In altre parole, tutti i prodotti Ethereum possono facilmente capirsi: questo rende i NFT trasferibili tra i vari prodotti. È possibile acquistare un NFT su un prodotto e venderlo su un altro senza problemi. Come creatore puoi elencare i tuoi NFT su più prodotti contemporaneamente: ogni prodotto avrà le informazioni di proprietà più aggiornate. -- Ethereum non dorme mai, e questo significa che i tuoi token saranno sempre disponibili per la vendita. +- Lo storico delle transazioni e i metadati del token sono verificabili pubblicamente: è semplice provare la storia della proprietà. +- Una volta confermata una transazione, è quasi impossibile manipolare quei dati per "rubarne" la proprietà. +- Lo scambio di NFT può verificarsi tra pari, senza necessitare di piattaforme che prelevano grandi parti come compensi. +- Tutti i prodotti di Ethereum condivodno lo stesso "backend". In altre parole, tutti i prodotti di Ethereum possono facilmente comprendersi a vicenda: rendendo i NFT trasferibili tra vari prodotti. Puoi facilmente acquistare un NFT su un prodotto e venderlo su un altro. Come creatore, puoi elencare i tuoi NFT su svariati prodotti allo stesso tempo; ogni prodotto conterrà le informazioni di proprietà più aggiornate. +- Ethereum non dorme mai, a significare che i token saranno sempre disponibili per la vendita. -## Impatto ambientale degli NFT {#environmental-impact-nfts} +## Impatto ambientale dei NFT {#environmental-impact-nfts} -La creazione ed il trasferimento degli NFT sono solo transazioni su Ethereum - il conio, l'acquisto, lo scambio o l'interazione con gli NFT non consumano direttamente energia. Dal momento in cui [la Fusione](/roadmap/merge) Ethereum è una blockchain a bassa consumo energetico, l'impatto ambientale dell'uso di NFT è trascurabile. +La creazione e il trasferimento dei NFT sono semplicemente transazioni di Ethereum: coniare, acquistare, scambiare o interagire con i NFT, non consuma direttamente energia. Da [La Fusione](/roadmap/merge), Ethereum è una blockchain a basso consumo energetico, a significare che l'impatto ambientale dell'utilizzo dei NFT, è trascurabile. -[Scopri di più sul consumo energetico di Ethereum](/energy-consumption/). +[Di più sul consumo energetico di Ethereum](/energy-consumption/). -### Non dare la colpa agli NFT {#nft-qualities} +### Non incolpare i NFT {#nft-qualities} -L'intero ecosistema degli NFT funziona perché Ethereum è decentralizzato e sicuro. +L'intero ecosistema dei NFT funziona perché Ethereum è decentralizzato e sicuro. -Decentralizzato significa che tu e tutti gli altri potete verificare che possiedi qualcosa. Il tutto senza fidarsi di terzi né affidare la custodia a terzi, che possono imporre le proprie regole a piacimento. Significa anche che il tuo NFT è trasferibile tra molti prodotti e mercati diversi. +Decentralizzato a significare che tu, come tutti gli altri, puoi verificare di possedere qualcosa. Il tutto senza affidarti o concedere la custodia a una terza parte, che potrebbe imporre le proprie regole a piacimento. Ciò significa anche che il tuo NFT è trasferibile tra molti prodotti e mercti differenti. -“Sicuro” significa che nessuno può copiare/incollare il tuo NFT o rubartelo. +Sicuro significa che nessuno può copiare e incollare il tuo NFT, o rubarlo. -Queste qualità di Ethereum rendono possibile possedere digitalmente oggetti unici e ottenere un prezzo equo per i tuoi contenuti. Ethereum protegge le risorse usando un meccanismo di consenso decentralizzato che prevede il ['proof-of-stake'](/developers/docs/consensus-mechanisms/pos). Si tratta di un metodo a basse emissioni di carbonio per determinare chi può aggiungere un blocco di transazioni alla catena, ed è considerato più sicuro dell'alternativa ['proof-of-work'](/developers/docs/consensus-mechanisms/pow), ad alto consumo energetico. Gli NFT sono stati associati a elevati consumi energetici perché Ethereum era protetto usando il proof-of-work. Oggi questo non è più vero. +Queste qualità di Ethereum rendono possibile il possesso digitale di oggetti univoci e l'ottenimento di prezzi equi per i propri contenuti. Ethereum protegge le risorse utilizzando un meccanismo di consenso decentralizzato, che prevede il [proof-of-stake](/developers/docs/consensus-mechanisms/pos). Si tratta di un metodo a basse emissioni, per determinare chi possa aggiungere un blocco di transazioni alla catena, ed è considerato più sicuro dell'alternativa ad alto consumo energetico precedente, il [proof-of-work](/developers/docs/consensus-mechanisms/pow). I NFT sono stati associati a elevati consumi energetici perché Ethereum era protetto utilizzando il proof-of-work. Oggi, quest'affermazione non è più vera. #### Coniare NFT {#minting-nfts} Quando si conia un NFT, devono accadere alcune cose: -- Deve essere confermato come un asset sulla blockchain. -- Il saldo del conto del proprietario dev'esser aggiornato per includere tale risorsa. In questo modo sarà successivamente possibile scambiarlo o "possederlo" in modo verificabile. -- Le transazioni che confermano l'esigenza suddetta di esser aggiunti a un blocco e "immortalati" sulla catena. -- Il blocco deve essere confermato da tutti nella rete come "corretto". Questo consenso elimina la necessità di intermediari, in quanto la rete accetta che il NFT esiste e appartiene a te. Inoltre, essendo sulla catena, può essere verificato da chiunque. Questo è uno dei modi in cui Ethereum aiuta i creatori di NFT a massimizzare i propri guadagni. +- Dev'essere confermato come una risorsa sulla blockchain. +- Il saldo del conto del proprietario dev'essere aggiornato per includere tale risorsa. Ciò rende possibile il suo successvo scambio, nonché di "possederlo" in modo verificabile. +- Le transazioni che confermano la suddetta esigenza, devono essere aggiunte a un blocco e "immortalate" sulla catena. +- Il blocco dev'essere confermato da tutti nella rete, come "corretto". Tale consenso elimina la necessità di intermediari, poiché la rete accetta che il NFT esiste e ti appartiene. Inoltre, trovandosi sulla catena, chiunque può verificarlo. Questo è uno dei modi in cui Ethereum aiuta i creatori di NFT a massimizzare i propri guadagni. -Tutte queste attività sono svolte dai produttori e validatori di blocchi. I propositori di blocchi aggiungono la transazione del tuo NFT a un blocco e la trasmettono al resto della rete. I validatori verificano che la transazione sia valida e, poi, la aggiungono ai loro database. Esistono molti incentivi cripto-economici per assicurarsi che i validatori agiscano con onestà. Altrimenti, chiunque potrebbe semplicemente rivendicare di essere il proprietario del NFT da te appena coniato e trasferirne la proprietà in modo fraudolento. +Tutte queste attività sono svolte dai produttori e validatori di blocchi. I propositori di blocchi aggiungono la transazione del tuo NFT a un blocco, trasmettendola al resto della rete. I validatori verificano che la transazione sia valida e, quindi, la aggiungono ai propri database. Esistono molti incentivi cripto-economici, per assicurarsi che i validatori agiscano con onestà. Altrimenti, chiunque potrebbe semplicemente rivendicare di possedere il NFT appena coniato, trasferendo in modo fraudolento la proprietà. -#### Sicurezza degli NFT {#nft-security} +#### Sicurezza dei NFT {#nft-security} -La sicurezza di Ethereum deriva dal proof-of-stake. Il sistema è progettato per disincentivare economicamente le azioni malevole, rendendo Ethereum a prova di manomissione. Questo è ciò che rende possibili gli NFT. Una volta che il blocco contenente la transazione del tuo NFT diventa definitivo, a un utente malevolo servirebbero milioni di ETH per modificarlo. Chiunque esegua il software di Ethereum potrebbe immediatamente rilevare la manomissione malevola di un NFT, e l'utente malevolo sarebbe penalizzato economicamente ed espulso. +La sicurezza di Ethereum deriva dal proof-of-stake. Il sistema è progettato per disincentivare economicamente le azioni malevole, rendendo Ethereum a prova di manomissione. Questo è ciò che rende possibili i NFT. Una volta che il blocco contenente la transazione del tuo NFT è finalizzato, a un utente malevolo servirebbero milioni di ETH per modificarlo. Chiunque esegua il software di Ethereum potrebbe rilevare immediatamente la manomissiione disonesta di un NFT e, l'utente malevolo, sarebbe penalizzato economicamente ed espulso. -I problemi di sicurezza degli NFT sono molto spesso correlati alle truffe di phishing, alle vulnerabilità dei contratti intelligenti o agli errori degli utenti (come esporre inavvertitamente le chiavi private), per questo una buona sicurezza del portafoglio è essenziale per i proprietari di NFT. +I problemi di sicurezza relativi ai NFT sono molto spesso relativi alle truffe di phishing, alle vulnerabilità dei contratti intelligenti o agli errori degli utenti (come esporre inavvertitamente le chiavi private), rendendo fondamentale una buona sicurezza dei portafogli, per i proprietari di NFT. Di più sulla sicurezza -## Costruire con i NFT {#build-with-nfts} +## Creare con i NFT {#build-with-nfts} -Gran parte degli NFT è creata usando uno standard coerente, noto come [ERC-721](/developers/docs/standards/tokens/erc-721/). Ma esistono anche altri standard che potrebbero interessarti. Lo standard [ERC-1155](/developers/docs/standards/tokens/erc-1155/) ammette i token semi-fungibili, particolarmente utili nel campo del gioco. E, più di recente, è stato proposto l'[EIP-2309](https://eips.ethereum.org/EIPS/eip-2309), per rendere molto più efficiente coniare NFT. Questo standard consente di coniarne in un'unica transazione qualunque numero di NFT! +Gran parte dei NFT è creata utilizzando uno standard coerente, noto come [ERC-721](/developers/docs/standards/tokens/erc-721/). Tuttavia, esistono altri standard che potrebbero interessarti. Lo standard [ERC-1155](/developers/docs/standards/tokens/erc-1155/) consente i token semi-fungibili, particolarmente utili nell'ambito videoludico. Più di recente, inoltre, è stata proposta l'[EIP-2309](https://eips.ethereum.org/EIPS/eip-2309), per rendere molto più efficiente il conio di NFT. Questo standard ti consente di coniarne quanti più ne desideri, in una singola transazione! ## Lettura consigliate {#further-reading} -- [Crypto art data](https://cryptoart.io/data) – Richard Chen, aggiornato automaticamente -- [OpenSea: the NFT Bible](https://opensea.io/blog/guides/non-fungible-tokens/) – _Devin Fizner, 10 Gennaio 2020_ -- [A beginner's guide to NFTs](https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d) – _Linda Xie, Gennaio 2020_ -- [Everything you need to know about the metaverse](https://foundation.app/blog/enter-the-metaverse) – _Foundation team, foundation.app_ -- [No, CryptoArtists Aren’t Harming the Planet](https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61) +- [Dati cripto-artistici](https://cryptoart.io/data): Richard Chen, aggiornato automaticamente +- [OpenSea: la Bibbia dei NFT](https://opensea.io/blog/guides/non-fungible-tokens/): _Devin Fizner, 10 Gennaio 2020_ +- [Una guida per principianti ai NFT](https://linda.mirror.xyz/df649d61efb92c910464a4e74ae213c4cab150b9cbcc4b7fb6090fc77881a95d): _Linda Xie, Gennaio 2020_ +- [Tutto ciò che devi sapere sul metaverso](https://foundation.app/blog/enter-the-metaverse): _Team della Foundation, foundation.app_ +- [No, i cripto-artisti non stanno danneggiando il pianeta](https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61) - [Consumo energetico di Ethereum](/energy-consumption/) +- [API NFT di Ethereum](https://www.alchemy.com/list-of/nft-apis-on-ethereum): _Alchemy_ diff --git a/src/content/translations/it/roadmap/account-abstraction/index.md b/src/content/translations/it/roadmap/account-abstraction/index.md new file mode 100644 index 00000000000..c5f6975ed69 --- /dev/null +++ b/src/content/translations/it/roadmap/account-abstraction/index.md @@ -0,0 +1,126 @@ +--- +title: Astrazione account +description: Un panoramica dei piani di Ethereum per rendere i conti degli utenti più semplici e sicuri +lang: it +summaryPoints: + - L'astrazione del conto semplifica molto la creazione di portafogli di contratti intelligenti + - I portafogli di contratti intelligenti semplificano molto la gestione dell'accesso ai conti di Ethereum + - Le chiavi perdute o esposte sono recuperabili utilizzando svariati backup +--- + +# Astrazione account {#account-abstraction} + +Gli utenti interagiscono con Ethereum utilizzando i **[conti posseduti esternamente (EOA)](/glossary/#eoa)**. Questo è il solo modo per avviare una transazione o per eseguire un contratto intelligente. Ciò limita il modo in cui gli utenti possono interagire con Ethereum. Ad esempio, rende difficile eseguire transazioni in massa e richiede agli utenti di mantenere sempre un saldo di ETH per coprire i costi del gas. + +L'astrazione del conto è un modo per risolvere tali problemi, consentendo agli utenti di programmare flessibilmente maggiore sicurezza e una migliore esperienza degli utenti, nei propri conti. Ciò può verificarsi [aggiornando gli EOA](https://eips.ethereum.org/EIPS/eip-3074) così che possano essere controllati da contratti intelligenti, o [aggiornando i contratti intelligenti](https://eips.ethereum.org/EIPS/eip-2938), così che possano avviare transazioni. Queste opzioni richiedono entrambe modifiche al protocollo di Ethereum. Esiste un terzo percorso che comporta l'aggiunta di un [secondo sistema separato di transazioni](https://eips.ethereum.org/EIPS/eip-4337) da eseguire in parallelo al protocollo esistente. Indipendentemente dal percorso, il risultato è l'accesso a Ethereum tramite i portafogli di contratti intelligenti, supportati nativamente come parte del protocollo esistente o tramite una rete di transazioni aggiuntiva. + +I portafogli di contratti intelligenti sbloccano molti benefici per l'utente, tra cui: + +- definire le proprie regole di sicurezza flessibili +- recuperare il proprio conto in caso di perdita delle chiavi +- condividere la sicurezza del proprio conto tra svariati dispositivi o individui +- pagare il gas altrui, o far pagare il proprio a qualcun altro +- raggruppare le transazioni (es. approvare ed eseguire uno scambio in una sola volta) +- incrementare le opportunità per gli svilupptori di dapp e portafogli, per innovare l'esperienza degli utenti + +Tali benefici non sono ad oggi supportati nativamente, poiché soltanto i conti posseduti esternamente ([EOA](https://ethereum.org/en/glossary/#eoa)) possono avviare le transazioni. Gli EOA sono semplicemente coppie di chiavi pubblica-privata. Funzionano come segue: + +- se hai la chiave privata puoi fare _qualsiasi cosa_ entro le regole della Macchina Virtuale di Ethereum (EVM) +- se non hai la chiave privata non puoi fare _nulla_. + +Se perdi le tue chiavi non sono recuperabili e le chiavi rubate danno ai ladri l'accesso istantaneo a tutti i fondi in un conto. + +I portafogli di contratti intelligenti sono la soluzione a tali problemi, ma a oggi sono difficili da programmare poiché, alla fine, qualsiasi logica che implementano dev'essere tradotta in una serie di transazioni dell'EOA, prima che possa essere elaborata da Ethereum. L'astrazione del conto consente ai contratti intelligenti di avviare da soli le transazioni, così che qualsiasi logica che l'utente desideri implementare possa essere programmata nel portafoglio del contratto intelligente stesso ed eseguita su Ethereum. + +Infine, l'astrazione del conto migliora il supporto ai portafogli di contratti intelligenti, semplificandone la creazione e aumentandone la sicurezza di utilizzo. Infine, con l'astrazione del conto, gli utenti possono godere di tutti i benefici di Ethereum, senza conoscere o interessarsi della tecnologia sottostante. + +## Oltre le frasi di seed {#beyond-seed-phrases} + +I conti odierni sono protetti utilizzando chiavi private, calcolate dalle frasi di seed. Chiunque abbia accesso a una frase di seed può scoprire facilmente la chiave privata che protegge un conto e ottenere accesso a tutte le risorse che protegge. Se una chiave privata e una frase di seed sono perdute, non sono mai recuperabili e le risorse che controllano sono congelate per sempre. Proteggere queste frasi di seed è alquanto bizzarro, persino per gli utenti esperti e il phishing delle frasi di seed è uno dei metodi più comuni per truffare gli utenti. + +L'astrazione del conto risolverà tale problema, utilizzando un contratto intelligente per detenere le risorse e autorizzare le transazioni. Questi contratti intelligenti sono quindi decorabili con logica personalizzata, per renderli il più sicuri e su misura possibile per l'utente. Infine, utilizzi ancora le chiavi private per controllare l'accesso al tuo conto, ma con reti di sicurezza che le rendono più facili e sicure da gestire. + +Ad esempio, le chiavi di backup possono essere aggiunte a un portafoglio, così che se perdi o esponi accidentalmente la tua chiave principale, può essere sostituita da una nuova e sicura, con l'autorizzazione dalle chiavi di backup. Potresti proteggere ognuna di queste chiavi in un modo differente, o dividerle tra guardiani fidati. Questo rende molto più difficile, per un ladro, ottenere il pieno controllo sui tuoi fondi. Similmente, puoi aggiungere regole al portafoglio per ridurre l'impatto nel caso in cui la tua chiave principale sia compromessa, ad esempio, potresti consentire le transazioni di basso valore affinché siano verificate da una singola firma, mentre le transazioni di valore superiore richiedono l'approvazione da svariati firmatari autenticati. Esistono altri modi in cui i portafogli di contratti intelligenti possono aiutarti a contrastare i ladri, ad esempio, una lista bianca è utilizzabile per bloccare ogni transazione a meno che non sia verso un indirizzo fidato o verificato da svariate delle tue chiavi pre-approvate. + +### Esempi di logica di sicurezza possono essere integrati in un portafoglio del contratto intelligente: + +- **Autorizzazione multifirma**: Puoi condividere le credenziali di autorizzazione tra svariate persone o dispositivi affidabili. Quindi, il contratto, è configurabile affinché le transazioni di più di un dato valore predeterminato, richiedano l'autorizzazione da una certa porzione (ad esempio, 3/5) delle parti fidate. Ad esempio, le transazioni dal valore elevato potrebbero richiedere l'approvazione sia da un dispositivo mobile che da un portafoglio hardware, o le firme dai conti distribuiti ai membri familiari fidati. +- **Congelamento del conto**: Se un dispositivo è perduto o compromesso, il conto può essere bloccato da un altro dispositivo autorizzato, proteggendo le risorse dell'utente. +- **Recupero del conto**: Hai perso un dispositivo o hai dimenticato una password? Nel paradigma corrente, ciò significa che le tue risorse potrebbero essere state congelate per sempre. Con il portafoglio di un contratto intelligente, puoi impostare dei conti pre-approvati che possano autorizzare nuovi dispositivi e ripristinare l'accesso. +- **Imposta limiti di transazione**: specifica le soglie giornaliere per il valore che può essere trasferito dal conto in un giorno/una settimana/un mese. Ciò significa che, se un utente malevolo ottiene l'accesso al tuo conto, non può prelevare tutto in una volta e hai l'opportunità di congelare e ripristinare l'accesso. +- **Crea liste bianche**: consenti soltanto le transazioni verso certi indirizzi che sai che sono sicuri. Ciò significa che _anche se_ la tua chiave privata è stata rubata, l'utente malevolo non potrebbe inviare i fondi a conti di destinazione non presenti nella lista bianca. Queste liste bianche richiederebbero più firme per modificarle, così che un utente malevolo non possa aggiungere il proprio indirizzo all'elenco, senza avere accesso a svariate delle tue chiavi di backup. + +## Migliore esperienza utente {#better-user-experience} + +L'astrazione del conto consente un'**esperienza dell'utente complessiva migliore**, nonché **maggiore sicurezza**, poiché aggiunge supporto ai portafogli di contratti intelligenti, a livello del protocollo. Il motivo più importante per questo è che fornirà agli sviluppatori di contratti intelligenti, portafogli e applicazioni, molta più libertà di innovare l'esperienza degli utenti, in modi che potrebbero ancora non essere capaci di anticipare. Alcuni miglioramenti ovvi che proverrebbero dall'astrazione del conto, includono il raggruppamento delle transazioni, per velocità ed efficienza. Ad esempio, un semplice scambio dovrebbe essere un'operazione in un click ma, oggi, richiede la firma di diverse transazioni per approvare la spesa di token individuali, prima dell'esecuzione dello scambio. L'astrazione del conto rimuove quella frizione, consentendo il raggruppamento delle transazioni. Inoltre, le transazioni raggruppate potrebbero approvare precisamente il valore corretto di token necessari per ogni transazione, per poi revocare le approvazioni al suo completamento, fornendo maggiore sicurezza. + +La gestione del gas, inoltre, è di molto migliorata con l'astrazione del conto. Non solo le applicazioni possono offrire di pagare le commissioni sul gas degli utenti ma, queste, possono essere pagate in token differenti da ETH, liberando gli utenti dal dover mantenere un saldo di ETH per finanziare le transazioni. Ciò potrebbe funzionare scambiando i token dell'utente per ETH nel contratto, quindi, utilizzando gli ETH per pagare il gas. + + + +La gestione del gas è una delle frizioni principali per gli utenti di Ethereum, principalmente perché gli ETH sono la sola risorsa utilizzabile per pagare le transazioni. Immagina di avere un portafoglio con un saldo di USDC, ma nessun ETH. Non puoi spostare o scambiare quei token USDC, poiché non puoi pagare il gas. Non puoi nemmeno scambiare gli USDC per ETH, poiché anche questo costa del gas. Dovresti inviare altri ETH al tuo conto da una piattaforma di scambio o da un altro indirizzo per risolvere il problema. Con i portafogli di contratti intelligenti, invece, puoi semplicemente pagare il gas in USDC, liberando il tuo conto. Non devi più mantenere un saldo di ETH in tutti i tuoi conti. + +L'astrazione del conto, inoltre, consente agli sviluppatori di dapp di essere creativi con la gestione del gas. Ad esempio, potresti riuscire a iniziare a pagare una commissione fissa mensile alla tua DEX preferita, per delle transazioni illimitate. Le Dapp potrebbero offrire di pagare tutte le tue commissioni di gas per conto tuo, come ricompensa per aver utilizzato la loro piattaforma, o come offerta di inserimento. Per gli sviluppatori, sarebbe molto più facile innovare sul gas, quando i portafogli di contratti intelligenti sono supportati al livello del protocollo. + + + +Le sessioni fidate, inoltre, sono potenzialmente trasformative per le esperienze degli utenti, specialmente per applicazioni come il gaming, in cui grandi numeri di piccole transazioni, potrebbero necessitare dell'approvazione in un breve tempo. Approvare individualmente ogni transazione spezzerebbe l'esperienza di gioco, ma l'approvazione permanente non è sicura. Il portafoglio di un contratto intelligente potrebbe approvare certe transazioni per un dato tempo, fino a un valore specifico o solo per certi indirizzi. + +Inoltre, è interessante considerare come gli acquisti potrebbero cambiare, con l'astrazione del conto. Oggi, ogni transazione dev'essere approvata ed eseguita da un portafoglio pre-finanziato con un importo sufficiente del token corretto. Con l'astrazione del conto, l'esperienza potrebbe somigliare di più allo shopping online di famiglia, in cui un utente potrebbe riempire un "carrello" di oggetti e cliccare una volta per acquistare tutto insieme, con tutta la logica necessaria gestita dal contratto, non dall'utente. + +Esistono solo alcuni esempi di come le esperienze degli utenti potrebbero essere migliorate dall'astrazione del conto, ma ne esisteranno molti altri, che non abbiamo ancora immaginato. L'astrazione del conto libera gli sviluppatori dai vincoli dei EOA dei giorni nostri, consente loro di portare i migliori aspetti del web2 al web3 senza sacrificare la custodia personale e di incidere creativamente sull'inventiva di nuove esperienze degli utenti. + +## Come sarà implementata l'astrazione del conto? {#how-will-aa-be-implemented} + +I portafogli di contratti intelligenti, ad oggi, esistono, ma implementarli è impegnativo poiché l'EVM non li supporta. Invece, si affidano all'avvolgimento di codice relativamente complesso, intorno alle transazioni standard di Ethereum. Ethereum può modificare tale procedimento, consentendo ai contratti intelligenti di avviare le transazioni, gestendo la logica necessaria nei contratti intelligenti di Ethereum, invece che al di fuori della catena. Inoltre, inserire la logica nei contratti intelligenti, incrementa la decentralizzazione di Ethereum, poiché rimuove il bisogno di "staffettisti" operati dagli sviluppatori dei portafogli, di tradurre i messaggi firmati dall'utente, in transazioni regolari di Ethereum. + + + +EIP-2771 introduce il concetto delle meta-transazioni, che consentono a terze parti di pagare i costi del gas degli utenti senza apportare modifiche al protocollo di Ethereum. L'idea è che le transazioni firmate da un utente sono inviate a un contratto `Corriere`. Il corriere è un'entità fidata che verifica che le transazioni siano valide, prima di inviarle a un ripetitore di gas. Ciò avviene all'esterno della catena, evitando il bisogno di pagare il gas. Il ripetitore di gas passa la transazione a un contratto `Destinatario`, pagando il gas necessario per rendere la transazione eseguibile su Ethereum. La transazione è eseguita se il `Corriere` è noto ed è ritenuto attendibile dal `Destinatario`. Questo modello semplifica, per gli sviluppatori, l'implementazione di transazioni a gas zero per gli utenti. + + + + + +L'EIP-4337 è il primo passo verso il supporto dei portafogli di contratti intelligenti nativi in modo decentralizzato, senza richiedere modifiche al protocollo di Ethereum. Invece di modificare il livello del consenso per supportare i portafogli di contratti intelligenti, un nuovo sistema è aggiunto separatamente al normale protocollo di gossip della transazione. Questo sistema di livello superiore si basa su un nuovo oggetto, detto UserOperation, che impacchetta le azioni da un utente, insieme alle firme rilevanti. Questi oggetti UserOperation, quindi, sono trasmessi in un mempool dedicato, dove i validatori possono raccoglierli in una "transazione raggruppata". La transazione raggruppata rappresenta una sequenza di molti UserOperations singoli e può essere inclusa nei blocchi di Ethereum, proprio come una normale transazione, che sarà raccolta dai validatori utilizzando un simile modello di selezione che massimizza le commissioni. + +Anche il funzionamento dei portafogli cambierà sotto EIP-4337. Invece di far reimplementare da ogni portafoglio una logica di sicurezza complessa ma comune, queste funzioni saranno affidate a un contratto del portafoglio globale, noto come "punto d'accesso". Questo, gestirebbe le operazioni come il pagamento delle commissioni e l'esecuzione del codice dell'EVM, così che gli sviluppatori di portafogli possano concentrarsi sul fornire eccellenti esperienze agli utenti. + +Nota: il contratto del punto d'accesso dell'EIP-4337, è stato distribuito alla Rete Principale di Ethereum l'1 marzo 2023. Puoi visualizzare il contratto su Etherscan. + + + + + +L'EIP-2938 mira ad aggiornare il protocollo di Ethereum introducendo un nuovo tipo di transazione, AA_TX_TYPE che include tre campi: nonce, target e data, dove nonce è un contatore di transazioni, target è l'indirizzo del contratto del punto d'accesso, e data è il bytecode dell'EVM. Per eseguire queste transazioni, devono essere aggiunte due nuove istruzioni (note come codici operativi) all'EVM: NONCE e PAYGAS. Il codice operativo NONCE traccia la sequenza della transazione e PAYGAS calcola e preleva il gas necessario per eseguire la transazione dal saldo del contratto. Queste nuove funzionalità consentono a Ethereum di supportare nativamente i portafogli di contratti intelligenti, poiché l'infrastruttura necessaria è integrata nel protocollo di Ethereum. + +Nota che l'EIP-2938 non è correntemente attiva. La community, al momento, preferisce EIP-4337 poiché non richiede modifiche al protocollo. + + + + + +L'EIP-3074 mira ad aggiornare i conti posseduti esternamente di Ethereum, consentendo loro di delegare il controllo a un contratto intelligente. Ciò significa che la logica dei contratti intelligenti potrebbe approvare le transazioni originate da un EOA. Questo consentirebbe funzionalità come la sponsorizzazione del gas e le transazioni raggruppate. Perché funzioni, devono essere aggiunti due nuovi codici operativi all'EVM: AUTH e AUTHCALL. Con l'EIP-3074, i benefici del portafoglio di un contratto intelligente sono resi disponibili senza la necessità di un contratto, invece un tipo specifico di contratto privo di stato, privo di fiducia e non ggiornabile, noto come "invocatore", gestisce le transazioni. + +Nota che EIP-3074 non è correntemente attivo. La community, al momento, preferisce EIP-4337 poiché non richiede modifiche al protocollo. + + + +## Stato attuale {#current-progress} + +I portafogli di contratti intelligenti sono già disponibili, ma sono necessari maggiori aggiornamenti per renderli il più decentralizzati e privi di permessi possibile. EIP-4337 è una proposta matura che non richiede alcuna modifica al protocollo di Ethereum, quindi è possibile che sarà implementata rapidamente. Tuttavia, gli aggiornamenti che alterano il protocollo di Ethereum non sono correntemente in sviluppo attivo, quindi potrebbe essere necessario più tempo per distribuire queste modifiche. Inoltre, è possibile che l'astrazione del conto sia raggiunta in modo soddisfacente da EIP-4337 e non sarà necessaria alcuna modifica al protocollo. + +## Letture consigliate {#further-reading} + +- [erc4337.io](https://www.erc4337.io/) +- [Discussione di gruppo sull'astrazione del conto dal Devcon Bogota](https://www.youtube.com/watch?app=desktop&v=WsZBymiyT-8) +- ["Perché l'astrazione del conto è una svolta per le dapp" da Devcon Bogota](https://www.youtube.com/watch?v=OwppworJGzs) +- ["Astrazione del conto ELI5" da Devcon Bogota](https://www.youtube.com/watch?v=QuYZWJj65AY) +- [Note di "Strada all'Astrazione del Conto" di Vitalik](https://notes.ethereum.org/@vbuterin/account_abstraction_roadmap#Transaction-inclusion-lists) +- [Post del blog di Vitalik sui portafogli di recupero sociale](https://vitalik.ca/general/2021/01/11/recovery.html) +- [Note sull'EIP-2938](https://hackmd.io/@SamWilsn/ryhxoGp4D#What-is-EIP-2938) +- [Documentazione sull'EIP-2938](https://eips.ethereum.org/EIPS/eip-2938) +- [Note sull'EIP-4337](https://medium.com/infinitism/erc-4337-account-abstraction-without-ethereum-protocol-changes-d75c9d94dc4a) +- [Documentazione sull'EIP-4337](https://eips.ethereum.org/EIPS/eip-4337) +- [Documentazione sull'EIP-2771](https://eips.ethereum.org/EIPS/eip-2771) +- ["Basi dell'Astrazione del Conto": Cos'è l'Astrazione del Conto Parte I](https://www.alchemy.com/blog/account-abstraction) diff --git a/src/content/translations/it/roadmap/beacon-chain/index.md b/src/content/translations/it/roadmap/beacon-chain/index.md index 2942b19d4df..0db25c3185e 100644 --- a/src/content/translations/it/roadmap/beacon-chain/index.md +++ b/src/content/translations/it/roadmap/beacon-chain/index.md @@ -13,27 +13,25 @@ summaryPoint3: La Beacon Chain ha introdotto la logica del consenso e il protoco La Beacon Chain è stata attivata l'1 dicembre 2020 e ha formalizzato il proof-of-stake come il meccanismo di consenso di Ethereum con l'aggiornamento della Fusione il 15 settembre 2022. -## Cos'era la Beacon Chain? {#what-is-the-beacon-chain} +## Cos'è la Beacon Chain? {#what-is-the-beacon-chain} -La Beacon Chain era il nome della blockchain di Proof of stake originale, lanciata nel 2020. Fu creata per assicurare che la logica di consenso di Proof of stake fosse stabile e sostenibile prima di abilitarla sulla Rete principale di Ethereum. Di conseguenza, era eseguita insieme all'Ethereum Proof of Work originale. La disattivazione del Proof of Work e l'attivazione del Proof of stake su Ethereum ha richiesto di istruire la Beacon Chain ad accettare le transazioni dalla catena Ethereum originale, a raggrupparle in blocchi e organizzarle in una blockchain usando il meccanismo di consenso basato sul Proof of stake. Allo stesso momento, i client originali di Ethereum hanno disattivato il proprio mining, la propagazione dei blocchi e la logica di consenso, passando tutti questi aspetti alla Beacon Chain. Questo evento è noto come [La Fusione](/roadmap/merge/). Una volta verificatasi La Fusione, non esistevano più due blockchain; era stata creata un'unica catena Proof of stake di di Ethereum. +Beacon Chain era il nome della blockchain di proof of stake originale, lanciata nel 2020. Fu creata per assicurare che la logica di consenso di Proof of stake fosse stabile e sostenibile prima di abilitarla sulla Rete principale di Ethereum. Di conseguenza, era eseguita insieme all'Ethereum Proof of Work originale. La Beacon Chain era una catena di blocchi 'vuoti', ma la disattivazione del proof of work e l'attivazione del proof of stake su Ethereum, hanno richiesto di istruire la Beacon Chain per accettare i dati delle transazioni dai client d'esecuzione, raggrupparli in blocchi, quindi organizzarli in una blockchain utilizzando il meccanismo di consenso basato sul proof of stake. Allo stesso momento, i client originali di Ethereum hanno disattivato il proprio mining, la propagazione dei blocchi e la logica di consenso, passando tutti questi aspetti alla Beacon Chain. Questo evento è noto come [La Fusione](/roadmap/merge/). Una volta verificatasi La Fusion, non esistevano più due blockchain. Invece, ora, esiste un singolo Ethereum di proof of stake, che richiede due client differenti per nodo. La Beacon Chain è ora il livello del consenso, una rete tra pari dei client del consenso, che gestisce il gossip dei blocchi e la logica di consenso, mentre i client originali formano il livello d'esecuzione, responsabile del gossip e dell'esecuzione delle transazioni, e della gestione dello stato di Ethereum. I due livelli possono comunicare tra loro utilizzando l'Engine API. -## Cosa faceva la Beacon Chain? {#what-does-the-beacon-chain-do} +## Cosa fa la beacon chain? {#what-does-the-beacon-chain-do} -La Beacon Chain era il nome dato a un registro di conti che conduceva e coordinava la rete di [staker](/staking/) di Ethereum, prima che questi iniziassero a convalidare transazioni reali di Ethereum. Non elaborava le transazioni, né gestiva le interazioni del contratto intelligente. - -Ha introdotto il motore di consenso (o "livello di consenso") che ha preso il posto del mining di Proof of Work su Ethereum, apportando con esso molti miglioramenti significativi. - -La Beacon Chain è stata un componente fondamentale per [l'Ethereum sicura, ecosostenibile e scalabile che conosciamo ora](/roadmap/vision/). +Beacon Chain è il nome dato a un libro mastro di conti che hanno condotto e coordinato la rete di [staker](/staking/) di Ethereum, prima che questi iniziassero a convalidare i blocchi reali di Ethereum. Però, essa non elabora le transazioni o gestisce le interazioni con i contratti intelligenti, poiché ciò è effettuato nel livello d'esecuzione. La Beacon Chain è responsabile di cose come la gestione dei blocchi e delle attestazioni, l'esecuzione dell'algoritmo di scelta della biforcazione e la gestione di ricompense e sanzioni. Leggi di più sulla nostra [pagina sull'architettura dei nodi](/developers/docs/nodes-and-clients/node-architecture/#node-comparison). ## Impatto della Beacon Chain {#beacon-chain-features} ### Introduzione allo staking {#introducing-staking} -La Beacon Chain ha introdotto la [Proof of stake](/developers/docs/consensus-mechanisms/pos/) in Ethereum. Questo mantiene sicura Ethereum e consente ai validatori di guadagnare più ETH nel processo. In pratica, lo staking prevede di puntare ETH per poter attivare il software del validatore. Come staker, esegui il software che crea e convalida i nuovi blocchi nella catena. +La Beacon Chain ha introdotto la [proof of stake](/developers/docs/consensus-mechanisms/pos/) in Ethereum. Questo mantiene sicura Ethereum e consente ai validatori di guadagnare più ETH nel processo. In pratica, lo staking prevede di puntare ETH per poter attivare il software del validatore. Come staker, esegui il software che crea e convalida i nuovi blocchi nella catena. Lo staking serve a uno scopo simile a quello del [mining](/developers/docs/mining/), ma è differente in molti modi. Il mining richiedeva ingenti spese iniziali sotto forma di hardware potente e consumi energetici, risultando in economie di scala e promuovendo la centralizzazione. Il mining, inoltre, non prevedeva alcun requisito di bloccare le risorse come garanzie, limitando la capacità del protocollo di punire gli utenti malevoli dopo un attacco. -La transizione al Proof of stake ha reso Ethereum significativamente più sicura e decentralizzata rispetto al Proof of Work. Più persone parteciperanno alla rete, più questa diventerà decentralizzata e protetta dagli attacchi. +La transizione al proof of stake ha reso Ethereum significativamente più sicura e decentralizzata rispetto al proof of work. Più persone parteciperanno alla rete, più questa diventerà decentralizzata e protetta dagli attacchi. + +E l'utilizzo del proof of stake come meccanismo di consenso è un componente fondamentale per [l'Ethereum sicuro, ecosostenibile e scalabile che conosciamo ora](/roadmap/vision/). Se sei interessato a diventare un validatore e contribuire a proteggere Ethereum, scopri di più sullo staking. @@ -43,11 +41,11 @@ La transizione al Proof of stake ha reso Ethereum significativamente più sicura Da quando la Beacon Chain si è fusa con la Rete principale originale di Ethereum, la community di Ethereum ha iniziato a cercare di ridimensionare la rete. -La Proof of stake ha il vantaggio di avere un registro di tutti i produttori di blocchi approvati in ogni momento, ognuno con ETH in staking. Questo registro getta le basi per la capacità di dividere e conquistare, ma ripartisce in modo affidabile le specifiche responsabilità della rete. +Il proof of stake ha il vantaggio di avere un registro di tutti i produttori di blocchi approvati in ogni momento, ognuno con ETH in staking. Questo registro getta le basi per la capacità di dividere e conquistare, ma ripartisce in modo affidabile le specifiche responsabilità della rete. -Questa responsabilità è in contrasto con il Poof of Work, in cui i miner non hanno obblighi verso la rete e potrebbero interrompere il mining e disattivare permanentemente il loro software del nodo in un istante, senza ripercussioni. Inoltre, non esiste alcun registro di propositori di blocchi noti e nessun modo affidabile per ripartire le responsabilità della rete in modo sicuro. +Questa responsabilità è in contrasto con il proof of work, in cui i miner non hanno obblighi verso la rete e potrebbero interrompere il mining e disattivare permanentemente il loro software del nodo in un istante, senza ripercussioni. Inoltre, non esiste alcun registro di propositori di blocchi noti e nessun modo affidabile per ripartire le responsabilità della rete in modo sicuro. -[Scopri di più sullo sharding](/roadmap/danksharding/) +[Maggiori informazioni sullo sharding](/roadmap/danksharding/) ## Relazione tra gli aggiornamenti {#relationship-between-upgrades} @@ -63,7 +61,7 @@ Inizialmente la Beacon Chain esisteva separatamente dalla Rete principale di Eth ### Shard chain e beacon chain {#shards-and-beacon-chain} -Lo sharding potrà entrare in modo sicuro nell'ecosistema Ethereum solo quando sarà presente un meccanismo di consenso Proof of stake. La Beacon Chain ha introdotto lo staking, che si è 'fuso' con la Rete principale, spianando la strada allo sharding per contribuire a ridimensionare ulteriormente Ethereum. +Lo sharding potrà entrare in modo sicuro nell'ecosistema Ethereum solo quando sarà presente un meccanismo di consenso proof of stake. La Beacon Chain ha introdotto lo staking, che si è 'fuso' con la Rete principale, spianando la strada allo sharding per contribuire a ridimensionare ulteriormente Ethereum. Shard chain @@ -72,4 +70,5 @@ Lo sharding potrà entrare in modo sicuro nell'ecosistema Ethereum solo quando s ## Letture consigliate - [Maggiori informazioni sugli aggiornamenti futuri di Ethereum](/roadmap/vision) -- [Maggiori informazioni sul proof-of-stake](/developers/docs/consensus-mechanisms/pos) +- [Maggiori informazioni sull'architettura dei nodi](/developers/docs/nodes-and-clients/node-architecture) +- [Maggiori informazioni sul proof of stake](/developers/docs/consensus-mechanisms/pos) diff --git a/src/content/translations/it/roadmap/danksharding/index.md b/src/content/translations/it/roadmap/danksharding/index.md new file mode 100644 index 00000000000..6d9d880c0a6 --- /dev/null +++ b/src/content/translations/it/roadmap/danksharding/index.md @@ -0,0 +1,91 @@ +--- +title: Danksharding +description: Informazioni su Proto-Danksharding e Danksharding - due aggiornamenti sequenziali per scalare Ethereum. +lang: it +summaryPoints: + - Il danksharding è un aggiornamento multi-fase per migliorare la scalabilità e la capacità di Ethereum. + - La prima fase, il Proto-Danksharding, aggiunge i blob di dati ai blocchi + - I blob di dati offrono un modo più economico per i rollup di pubblicare i dati su Ethereum, tali costi possono essere trasferiti agli utenti sotto forma di commissioni di transazione inferiori. + - In seguito, il Dansharding completo diffonderà la responsabilità di verificare i blob di dati tra i sottoinsiemi di nodi, ridimensionando ulteriormente Ethereum, a oltre 100.000 transazioni al secondo. +--- + +# Danksharding {#danksharding} + +Il **Danksharding** è il metodo tramite cui Ethereum diventa una blockchain realmente scalabile ma, per arrivarci, sono necessari diversi aggiornamenti del protocollo. Il **Proto-Danksharding** è un passaggio intermedio, lungo tale percorso. Entrambi mirano a rendere le transazioni sul Livello 2 quanto più possibile economiche per gli utenti e dovrebbero ridimensionare Ethereum a >100.000 transazioni al secondo. + +## Cos'è il Proto-Danksharding? {#what-is-protodanksharding} + +Il Proto-Danksharding, anche noto come [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844), è un metodo per i [rollup](/layer2/#rollups) per aggiungere dati più economici ai blocchi. Il nome proviene dai due ricercatori che hanno proposto l'idea: Protolambda e Dankrad Feist. Al momento, i rollup sono limitati, relativamente all'economicità a cui possono compiere le transazioni degli utenti, dal fatto che pubblicano le proprie transazioni in `CALLDATA`. Ciò è costoso poiché è elaborato da tutti i nodi di Ethereum e risiede per sempre sulla catena, anche se i rollup necessitano dei dati soltanto per un breve periodo. Il Proto-Danksharding introduce i blob di dati, inviabili e collegabili ai blocchi. I dati in tali blob non sono accessibili all'EVM e sono eliminati automaticamente dopo un periodo di tempo fisso (1-3 mesi). Ciò significa che i rollup possono inviare i propri dati in modo molto più economico, trasferendo i risparmi agli utenti finali nella forma di transazioni più economiche. + + + +I rollup sono un metodo per scalare Ethereum raggruppando le transazioni all'esterno della catena e, in seguito, pubblicando i risultati su Ethereum. Un rollup, essenzialmente, si compone di due parti: dati e controllo dell'esecuzione. I dati sono la sequenza completa delle transazioni elaborate da un rollup per produrre il cambiamento di stato pubblicato su Ethereum. Il controllo d'esecuzione è la ri-esecuzione di tali transazioni da un utente onesto (dimostratore) per aassicurarsi che il cambiamento di stato proposto sia corretto. Per poter effettuare il controllo d'esecuzione, i dati della transazione devono essere disponibili per un tempo sufficiente perché chiunque possa scaricarli e controllarli. Ciò significa che qualsiasi comportamento disonesto dal sequenziatore del rollup puà essere identificato e sfidato dal dimostratore. Tuttavia, non è necessario che sia disponibile per sempre. + + + + + +I rollup pubblicano gli impegni ai dati delle proprie transazioni on chain e, inoltre, rendono disponibili i dati effettivi nei blob di dati. Ciò significa che i dimostratori possono verificare che gli impegni siano validi o sfidare i dati che ritengono siano errati. Al livello del nodo, i blob di dati sono conservati nel client del consenso. I client del consenso attestano di aver visto i dati e che sono stati propagati per la rete. Se i dati fossero conservati per sempre, tali client si allargherebberò, determinando grandi requisiti hardware per l'esecuzione di nodi. Invece, i dati, sono eliminati automaticamente dal nodo ogni 1-3 mesi. Le attestazioni del client del consenso dimostrano che vi è stata un'opportunità sufficiente, affinché i dimostratori potessero verificare i dati. I dati effettivi possono essere memorizzati off-chain dagli operatori di rollup, dagli utenti o da terzi. + + + +### Come sono verificati i dati dei blob? {#how-are-blobs-verified} + +I rollup pubblicano le transazioni che eseguono nei blob di dati. Inoltre, pubblicano un "impegno" ai dati. Lo fanno fissando una funzione polinomiale ai dati. Questa è valutabile su vari punti. Ad esempio, se definiamo una funzione estremamente semplice `f(x) = 2x-1`, possiamo valutarla per `x = 1`, `x = 2`, `x = 3`, che danno i risultati `1, 3, 5`. Un dimostratore applica la stessa funzione ai dati, valutandoli sugli stessi punti. Se i dati originali vengono modificati, la funzione non sarà identica e quindi i valori non sono valutati in ciascun punto. In realtà, l'impegno e la prova sono più complicati poiché sono avvolti in funzioni crittografiche. + +### Cos'è KZG? {#what-is-kzg} + +KGZ sta per Kate-Zaverucha-Goldberg, i nomi dei tre [autori originali](https://link.springer.com/chapter/10.1007/978-3-642-17373-8_11) di uno schema che riduce un blob di dati a un piccolo ["impegno" crittografico](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html). Il blob di dati inviato da un rollup dev'essere verificato per assicurarsi che il rollup si stia comportando correttamente. Ciò richiede la ri-esecuzione delle transazioni nel blob da un dimostratore, per verificare che l'impegno sia valido. Questo equivale, concettualmente, al metodo con cui i client d'esecuzione verificano la validità delle transazioni di Ethereum sul livello 1, utilizzando le prove di Merkle. KZG è una prova alternativa che adatta un'equazione polinomiale ai dati. L'impegno valuta la polinomiale a determinati punti di dati segreti. Un dimostratore si adatterebbe alla stessa polinomiale sui dati, valutandola agli stessi valori e verificando che i risultati corrispondano. Questo è un modo per verificare che sia compatibile con le tecniche di conoscenza zero, utilizzate da alcuni rollup ed, eventualmente, da altre parti del protocollo di Ethereum. + +### Cos'è la cerimonia KZG? {#what-is-a-kzg-ceremony} + +Una cerimonia KZG è un metodo, per molte persone da tutta la community di Ethereum, di generare una stringa casuale segreta di numeri, utilizzabile per verificare dei dati. È molto importante che tale stringa di numeri non sia nota e non possa essere ricreata da nessuno. Per assicurarlo, ogni partecipante alla cerimonia riceve una stringa dal partecipante precedente. Quindi, possono creare dei nuovi valori casuali (ad esempio, consentendo al proprio browser di misurare il movimento del proprio mouse) e mischiandoli con il valore precedente. Quindi, inviano il valore al partecipante successivo e lo eliminano dalla propria macchina locale. Finché una persona nella cerimonia lo fa onestamente, il valore finale sarà sconosciuto a un utente malevolo. La cerimonia KZG dell'EIP-4844 è stata aperta al pubblico e decine di migliaia di persone hanno partecipato per aggiungere la propria entropia. Affinché la cerimonia sia compromessa, il 100% di questi partecipanti avrebbe dovuto essere attivamente disonesto. Dalla prospettiva dei partecipanti, se sanno di essere onesti, non è necessario fidarsi di nessun altro, poiché sanno di aver protetto la cerimonia (soddisfacendo individualmente il requisito del partecipante onesto "1 di N"). + + + +Quando un rollup pubblica i dati in un blob, fornisce un "impegno", pubblicato sulla catena. Questo, è il risultato della valutazione di un adattamento polinomiale ai dati, in certi punti. Questi punti sono definiti dai numeri casuali generati nella cerimonia KZG. I dimostratori, quindi, possono valutare la polinomiale agli stessi punti, per poter verificare i dati; se arrivano agli stessi valori, allora i dati sono corretti. + + + + + +Se qualcuno conoscesse le posizioni casuali utilizzate per l'impegno, sarebbe facile, per loro, generare una nuova polinomiaale che si adatti a quei punti specifici (cioè, una "collisione"). Ciò significa che potrebbero aggiungere o rimuovere i dati dal blob e, comunque, fornire una prova valida. Per impedirlo, invece di dare ai dimostratori le posizioni segrete effettive, ricevono in realtà le posizioni, avvolte in una "scatola nera" crittografica, utilizzando le curve ellittiche. Questi, infatti, rimescolano i valori in modo tale che i valori originali non siano decodificabili, ma con dimostratori e verificatori capaci in algebra, le polinomiali sono ancora valutabili ai punti rappresentati. + + + + + Né il Danksharding, né il Proto-Danksharding seguono il modello di "frammentazione" tradizionale, che mirava alla divisione della blockchain in più parti. Le catene di frammenti non fanno più parte della tabella di marcia. Invece, il Danksharding utilizza il campionamento dei dati distribuiti tra blob, per ridimensionare Ethereum. Ciò è molto più semplice da implementare. Questo modello, talvolta, è stato indicato come "frammentazione dei dati". + + +## Cos'è il Danksharding? {#what-is-danksharding} + +Il Danksharding è la piena realizzazione del ridimensionamento del rollup, avviata con il Proto-Danksharding. Il Dankshaarding comporterà enormi quantità di spazio su Ethereum, dove i rollup potranno riversare i dati compressi delle loro transazioni. Ciò significa che Ethereum potrà supportare centinaia di rollup individuali con facilità, rendendo realtà milioni di transazioni al secondo. + +Ciò funziona espandendo i blob collegati ai blocchi da 1 nel Proto-Danksharding a 64 nel Danksharding completo. Il resto delle modifiche necessarie sono tutti gli aggiornamenti al metodo di operazione dei client del consenso, per consentire loro di gestire i nuovi, grandi blob. Svariate di queste modifiche sono già sulla tabella di marcia per altri scopi, indipendenti dal Danksharding. Ad esempio, il Danksharding richiede la separazione del propositore e del costruttore, per essere implementata. Questo è un aggiornamento che separa le mansioni di costruzione e proposta dei blocchi, tra validatori differenti. Similmente, il campionamento della disponibilità dei dati è necessario per il Danksharding, ma è anche necessario per lo sviluppo di client molto leggeri, che non memorizzano molti dati storici ("client privi di stato"). + + + +La separazione di propositori e costruttori è necessaria per impedire ai singoli validatori di dover generare costosi impegni e prove, per 32 MB di dati del blob. Questo metterebbe a dura prova gli staker domestici e richiederebbe loro di investire in hardware più potenti, danneggiando la decentralizzazione. Invece, i costruttori di blocchi specializzati si prendono la responsabilità di questo costoso lavoro di calcolo. Poi, mettono a disposizione i propri blocchi ai propositori di blocchi per la trasmissione. Il propositore di blocchi, semplicemente, sceglie il blocco più redditizio. Chiunque può verificare i blob in modo economico e rapido, a significare che ogni normale validatore può verificare che i costruttori di blocchi si stiano comportando onestamente. Ciò consente ai blob grandi di essere elaborati, senza sacrificare la decentralizzazione. I costruttori di blocchi malevoli potrebbero semplicemente essere esplusi dalla rete e tagliati; altri arriverebbero al loro posto, poiché la costruzione di blocchi è un'attività redditizia. + + + + + +Il campionamento della disponibilità dei dati è necessario perché i validatori verifichino in modo rapido ed efficace i dati dei blob. Utilizzando il campionmento della disponibilità dei dati, i validatori possono essere davvero certi che i blob di dati fossero disponibili e che siano stati inviati correttamente. Ogni validatore può campionare casualmente alcuni punti di dati e creare una prova, a significare che nessun validatore deve verificare l'intero blob. Se mancano dei dati, saranno identificati rapidamente e il blob sarà respinto. + + + +### Stato attuale {#current-progress} + +Il Danksharding completo dista svariati anni. Tuttavia, il Proto-Danksharding dovrebbe arrivare relativamente presto. Al momento della scrittura (Feb 2023), la cerimonia KZG è ancora aperta e finora ha attirato oltre 50.000 collaboratori. L'[EIP](https://eips.ethereum.org/EIPS/eip-4844) per il Proto-Danksharding è matura, le specifiche sono concordate e i client hanno implementato dei prototipi, attualmente in fase di prova e preparazione alla produzione. La prossima fase è implementare le modifiche su una rete di prova pubblica. Puoi tenerti aggiornato utilizzando la [lista di controllo di prontezza dell'EIP-4844](https://github.com/ethereum/pm/blob/master/Breakout-Room/4844-readiness-checklist.md#client-implementation-status). + +### Letture consigliate {#further-reading} + +- [Note sul Proto-Danksharding](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq) - _Vitalik Buterin_ +- [Note di Dankrad sul Danksharding](https://notes.ethereum.org/@dankrad/new_sharding) +- [Dankrad, Proto e Vitalik discutono sul Danksharding](https://www.youtube.com/watch?v=N5p0TB77flM) +- [La cerimonia KZG](https://ceremony.ethereum.org/) +- [Il discorso di Carl Beekhuizen al Devcon sulle configurazioni attendibili](https://archive.devcon.org/archive/watch/6/the-kzg-ceremony-or-how-i-learnt-to-stop-worrying-and-love-trusted-setups/?tab=YouTube) +- [Maggiori informazioni sul campionamento della disponibilità dei dati per i blob](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling) +- [Dankrad Feist su impegni e prove del KZG](https://youtu.be/8L2C6RDMV9Q) +- [Impegni polinomiali KZG](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html) diff --git a/src/content/translations/it/roadmap/future-proofing/index.md b/src/content/translations/it/roadmap/future-proofing/index.md new file mode 100644 index 00000000000..f65f3cc2d88 --- /dev/null +++ b/src/content/translations/it/roadmap/future-proofing/index.md @@ -0,0 +1,38 @@ +--- +title: Rendere Ethereum a prova di futuro +description: Questi aggiornamenti cementano Ethereum come lo strato fondamentale, resiliente e decentralizzato per il futuro, indipendentemente da ciò che conterrà. +lang: it +image: ../../../../../assets/roadmap/roadmap-future.png +alt: "Roadmap di Ethereum" +template: roadmap +--- + +Alcune parti della tabella di marcia non sono necessariamente richieste per ridimensionare o proteggere Ethereum sul breve termine, ma per organizzarlo per la stabilità e affidabilità future. + +## Resistenza quantistica {#quantum-resistance} + +Parte della protezione crittografica odierna di Ethereum sarà compromessa quando i computer quantistici diverranno una realtà. Sebbene i computer quantistici siano probabilmente a decenni dall'essere una vera minaccia per la crittografia moderna, Ethereum ha una struttura che ne garantisce la sicurezza nei secoli a venire. Ciò significa rendere [Ethereum resistente ai computer quantistici](https://consensys.net/blog/developers/how-will-quantum-supremacy-affect-blockchain/), il prima possibile. + +La sfida affrontata dagli sviluppatori di Ethereum è che l'attuale protocollo di proof-of-stake si affida a uno schema di firme molto efficiente, noto come BLS, per aggregare i voti su blocchi validi. Questo schema di firme è infranto dai computer quantistici, ma le alternative resistenti a essi non sono altrettanto efficaci. + +Gli [schemi di impegno "KZG"](/roadmap/danksharding/#what-is-kzg) utilizzati in svariati punti su Ethereum per generare frasi segrete crittografiche sono noti per la loro vulnerabilità ai computer quantistici. Al momento, il problema viene eluso utilizzando le "configurazioni fidate", in cui molti utenti generano casualità non decodificabili da un computer quantistico. Tuttavia, la soluzione ideale sarebbe semplicemente incorporare, piuttosto, la crittografia sicura contro i computer quantistici. Esistono due approcci principali che potrebbero divenire efficienti sostituti per lo schema BLS: la firma [basata su STARK](https://hackmd.io/@vbuterin/stark_aggregation) e [basata su reticolo](https://medium.com/asecuritysite-when-bob-met-alice/so-what-is-lattice-encryption-326ac66e3175). Queste, sono ancora ricercate e prototipate. + + Leggi su KZG e le configurazioni fidate + +## Un Ethereum più semplice ed efficiente {#simpler-more-efficient-ethereum} + +La complessità crea opportunità per bug o vulnerabilità sfruttabili dagli utenti malevoli. Dunque, parte della tabella di marcia è semplificare Ethereum e rimuovere il codice rimanente dai vari aggiornamenti, ma non più necessario o migliorabile. Una base di codice più snella e semplice è, per gli sviluppatori, più facile da mantenere, nonché da ragionare. + +Esistono diversi aggiornamenti che saranno apportati alla [Macchina Virtuale di Ethereum (EVM)](/developers/docs/evm), per renderla più semplice ed efficiente. Questi includono la [rimozione del codice operativo SELFDESTRUCT](https://hackmd.io/@vbuterin/selfdestruct): un comando raramente utilizzato e non più necessario che, in certe circostanze, può essere pericoloso da usare, specialmente quando combinato con altri aggiornamenti futuri al modello di archiviazione di Ethereum. Inoltre, i client di Ethereum supportano ancora i vecchi tipi di transazioni, che possono ora essere completamente rimossi. Anche il metodo di calcolo del gas è migliorabile e possono essere introdotti metodi più efficienti per il sostegno aritmetico di certe operazioni crittografiche. + +Similmente, esistono aggiornamenti apportabili ad altre parti dei client odierni di Ethereum. Un esempio sono i client d'esecuzione e consenso odierni, che utilizzano un tipo di compressione dei dati differente. Sarebbe molto più facile e intuitivo condividere i dati tra i client, quando lo schema di compressione è unificato per l'intera rete. + +## Stato attuale {#current-progress} + +Gran parte degli aggiornamenti necessari per rendere Ethereum a prova di futuro sono ancora in fase di ricerca e potrebbero essere a distanza di svariati anni dall'essere implementati. Gli aggiornamenti come la rimozione di SELF-DESTRUCT e l'armonizzazione dello schema di compressione utilizzato nei client d'esecuzione e del consenso potrebbero arrivare prima della crittografia resistente ai computer quantistici. + +**Letture consigliate** + +- [Gas](/developers/docs/gas) +- [EVM](/developers/docs/evm) +- [Strutture di dati](/developers/docs/data-structures-and-encoding) diff --git a/src/content/translations/it/roadmap/index.md b/src/content/translations/it/roadmap/index.md new file mode 100644 index 00000000000..7033497a271 --- /dev/null +++ b/src/content/translations/it/roadmap/index.md @@ -0,0 +1,117 @@ +--- +title: Roadmap di Ethereum +description: Il percorso verso una maggiore scalabilità, sicurezza e sostenibilità per Ethereum. +lang: it +template: roadmap +image: ../../assets/roadmap/roadmap-main.png +alt: "Roadmap di Ethereum" +summaryPoints: +buttons: + - label: Ulteriori aggiornamenti + toId: what-changes-are-coming + - label: Aggiornamenti precedenti + to: /history/ + variant: outline +--- + +Ethereum è già una potente piattaforma per il coordinamento globale, ma è ancora in fase di miglioramento. Una serie ambiziosa di miglioramenti trasformerà Ethereum dalla sua forma attuale in una piattaforma completamente scalata e al massimo resiliente. Questi aggiornamenti sono previsti nella tabella di marcia di Ethereum. + +**Per conoscere gli aggiornamenti precedenti a Ethereum, vi preghiamo di visita la nostra pagina [Cronologia](/history/)** + +## Quali cambiamenti stanno arrivando su Ethereum? {#what-changes-are-coming} + +La tabella di marcia Ethereum delinea i miglioramenti specifici che saranno apportati al protocollo in futuro. Nel complesso, la tabella di marcia apporterà i seguenti vantaggi agli utenti di Ethereum: + + + + + + + + +## Perché Ethereum necessita di una tabella di marcia? {#why-does-ethereum-need-a-roadmap} + +Ethereum riceve aggiornamenti regolari che migliorano la sua scalabilità, sicurezza o sostenibilità. Uno dei punti di forza di Ethereum è l'adattamento man mano che nuove idee emergono dalla ricerca e sviluppo. L'adattabilità offre a Ethereum la flessibilità per affrontare le sfide emergenti e tenere il passo con le innovazioni tecnologiche più avanzate. + + + +La tabella di marcia è principalmente il risultato di anni di lavoro da parte di ricercatori e sviluppatori - perché il protocollo è molto tecnico - ma qualsiasi persona motivata può partecipare. Le idee di solito iniziano come discussioni su un forum come [ethresear.ch](https://ethresear.ch/), [Ethereum magicians](https://www.figma.com/exit?url=https%3A%2F%2Fethereum-magicians.org%2F) o il server Eth R&D discord. Possono essere risposte a nuove vulnerabilità che vengono scoperte, suggerimenti da parte di organizzazioni che lavorano nel livello dell'applicazione (come dapps e borse) o da attriti conosciuti per gli utenti finali (come costi o velocità di transazione). Quando queste idee maturano, possono essere proposte come [Ethereum Improvement Proposals](https://eips.ethereum.org/). Tutto questo viene fatto in pubblico in modo che chiunque della comunità possa esprimere la propria opinione in qualsiasi momento. + +[Ulteriori informazioni sulla governance di Ethereum](/governance/) + + + + +

Cos'è stato l'ETH?

+ +

Il termine 'Eth2' è stato comunemente usato per descrivere il futuro di Ethereum prima del passaggio alla proof-of-stake ma è stato gradualmente eliminato a favore di una terminologia più precisa. Originariamente è stato utilizzato per differenziare la rete Ethereum prima del passaggio alla proof-of-stake e la rete successiva, o a volte per fare riferimento ai diversi clienti di Ethereum (i clienti di esecuzione sono stati talvolta denominati clienti ETH1 e i clienti di consenso sono stati talvolta denominati clienti ETH2).

+ + + +## La tabella di marcia di Ethereum cambierà nel tempo? {#will-ethereums-roadmap-change-over-time} + +Sì, quasi definitivamente. La tabella di marcia è l'attuale piano per l'aggiornamento di Ethereum, che copre sia i piani a breve termine che quelli futuri. Ci aspettiamo che la tabella di marcia cambi man mano che saranno disponibili nuove informazioni e tecnologie. + +Pensa alla tabella di marcia di Ethereum come a una serie di intenzioni per migliorare Ethereum; è l'ipotesi migliore dei ricercatori e sviluppatori centrali del percorso ottimale di Ethereum. + +## Quando terminerà la tabella di marcia? {#when-will-the-roadmap-be-finished} + +Ethereum implementerà alcuni aggiornamenti nei prossimi sei mesi (ad es. prelievi dallo staking); altri sono meno prioritari e probabilmente non saranno attuati per i prossimi 5-10 anni (ad esempio resistenza quantistica). Dare tempi precisi per ogni aggiornamento è complicato poichémolti elementi della tabella di marcia vengono elaborati in parallelo e sviluppati a velocità diverse. L'urgenza di un aggiornamento può anche cambiare nel tempo a seconda di fattori esterni (ad es. un salto avanti improvviso nelle prestazioni e nella disponibilità di computer quantistici può rendere più urgente la crittografia a resistenza quantistica). + +Un modo in cui pensare allo sviluppo di Ethereum è per analogia all'evoluzione biologica. Una rete in grado di adattarsi alle nuove sfide e di mantenere l'idoneità ha più probabilità di successo rispetto una che oppone resistenza al cambiamento, anche se man mano che la rete diventa sempre più performante, scalabile e sicura, richeiderà meno modifiche al protocollo. + +## Devo fare qualcosa quando c'è un aggiornamento? {#do-i-have-to-do-anything-when-there-is-an-upgrade} + +Gli aggiornamenti tendono a non influenzare gli utenti finali e forniscono migliori esperienze utente e un protocollo più sicuro e forze più modalità di opzioni interazione con Ethereum. Gli usi finali non sono tenuti a partecipare attivamente a un aggiornamento, né sono tenuti a fare nulla per garantire i loro beni. Gli operatori dei nodi dovranno aggiornare i loro client per prepararsi a un aggiornamento. Alcuni aggiornamenti possono portare a modifiche per gli sviluppatori di applicazioni. Ad esempio, gli aggiornamenti della scadenza della cronologia possono indurre gli sviluppatori di applicazioni a prendere i dati storici da nuove fonti. + +## Che cosa sono l'Orlo, lo Spreco, ecc.? {#what-about-the-verge-splurge-etc} + +[Vitalik Buterin ha proposto una visione per la tabella di marcia di Ethereum](https://twitter.com/VitalikButerin/status/1588669782471368704) che è stata organizzata in diverse categorie legate dai loro effetti sull'architettura di Ethereum. Tale visione comprendeva: + +- La Fusione: aggiornamenti relativi al passaggio dal proof-of-work al proof-of-stake +- L'Ondata: aggiornamenti correlati alla scalabilità tramite rollup e frammentazione dei dati +- Il Flagello: aggiornamenti correlati alla resistenza alla censura, alla decentralizzazione e ai rischi di protocollo dal MEV +- L'Orlo: aggiornamenti correlati alla verifica semplificata dei blocchi +- L'Epurazione: aggiornamenti correlati alla riduzione dei costi di calcolo dell'esecuzione dei nodi e semplificazione del protocollo +- Lo Spreco: altri aggiornamenti che non si adattano bene alle categorie precedenti. + +Abbiamo deciso di non utilizzare questa terminologia perché volevamo utilizzare un modello più semplice e incentrato sull'utente. Sebbene utilizziamo un linguaggio incentrato sugli utenti, la visione resta la stessa proposta da Vitalik. + +## Cos'è la frammentazione? {#what-about-sharding} + +La frammentazione consiste nella divisione della blockchain di Ethereum, così che dei sottoinsiemi di validatori siano responsabili soltanto per una frazione dei dati totali. Questo doveva essere il metodo originariamente inteso per il ridimensionamento di Ethereum. Tuttavia, i rollup di livello 2 si sono sviluppati molto più velocemente del previsto, fornendo già un grande ridimensionamento, e ne forniranno molto altro dopo l'implementazione del Proto-Danksharding. Ciò significa che le "catene di frammenti" non sono più necessarie e sono state rimosse dalla tabella di marcia. + +## Cerchi aggiornamenti tecnici specifici? {#looking-for-specific-technical-upgrades} + +- [Danksharding](/roadmap/danksharding) - Il Danksharding rende i rollup di livello 2 molto più economici, aggiungendo dei "blob" di dati ai blocchi di Ethereum. +- [Prelievi di Staking](/staking/withdrawals): L'aggiornamento di Shanghai/Capella ha consentito i prelievi di staking su Ethereum, consentendo alle persone di sbloccare i propri ETH in staking. +- [Finalità dello spazio singolo](/roadmap/single-slot-finality): Invece di attendere quindici minuti, i blocchi potrebbero essere proposti e finalizzati nello stesso spazio. Ciò è più comodo per le app e molto più difficile da attaccare. +- [Separazione tra propositori e costruttori](/roadmap/pbs): Divisione delle mansioni di costruzione e proposta dei blocchi tra validatori separati, creando un metodo più giusto, resistente alla censura ed efficiente per Ethereum, per arrivare al consenso. +- [Elezione segreta di un capo](/roadmap/secret-leader-election): Una crittografia intelligente è utilizzabile per assicurarsi che l'identità del propositore di blocchi corrente non sia resa pubblica, proteggendolo da certi tipi di attacchi. +- [Astrazione del conto](/roadmap/account-abstraction): L'astrazione del conto è una classe di aggiornamenti che supportano nativamente i portafogli di contratti intelligenti su Ethereum, invece di dover utilizzare middleware complessi. +- [Alberi di Verkle](/roadmap/verkle-trees): Gli alberi di Verkle sono strutture di dati utilizzabili per consentire i client privi di stato su Ethereum. Questi client "privi di stato" richiederanno una minuscola quantità di spazio di archiviazione, ma potranno comunque verificare i nuovi blocchi. +- [Assenza di stato](/roadmap/statelessness): i client privi di stato potranno verificare i nuovi blocchi senza dover memorizzare grandi quantità di dati. Questo fornirà tutti i benefici dell'operazione di un nodo, con soltanto una minuscola frazione dei costi odierni. diff --git a/src/content/translations/it/roadmap/merge/index.md b/src/content/translations/it/roadmap/merge/index.md index 1c019092dc0..c9f55308670 100644 --- a/src/content/translations/it/roadmap/merge/index.md +++ b/src/content/translations/it/roadmap/merge/index.md @@ -91,15 +91,18 @@ title="Sviluppatori di dapp e contratti intelligenti" contentPreview="The Merge was designed to have minimal impact on smart contract and dapp developers." id="developers"> -La Fusione comporta modifiche al consenso, che includono anche modifiche correlate a: +La Fusione è stata accompagnata da modifiche al consenso, incluse anche modifiche relative a:< -- la struttura del blocco -- tempistiche dello slot/blocco -- modifiche all'opcode -- fonti di casualità su catena -- concetto di _testa sicura_ e _blocchi finalizzati_ +
    +
  • struttura del blocco
    • +
  • tempistiche spazio/blocco
    • +
  • modifiche ai codici operativi
    • +
  • fonti di casualità su catena on-chain
    • +
  • concetto di testa sicura e blocchi finalizzati
    • +
+ +Per ulteriori informazioni, consulta questo post del blog di Tim Beiko su Come La Fusione Influenza il Livello d'Applicazione di Ethereum. -Per ulteriori informazioni, dai un'occhiata a questo post del blog di Tim Beiko su [Come La Fusione Influisce sul Livello di Applicazione di Ethereum](https://blog.ethereum.org/2021/11/29/how-the-merge-impacts-app-layer/). ## La Fusione e il consumo energetico {#merge-and-energy} @@ -115,26 +118,29 @@ La Fusione ha inoltre gettato le basi per ulteriori aggiornamenti di scalabilit + Esistono due tipi di nodi di Ethereum: i nodi che possono proporre blocchi e quelli che non possono. I nodi che propongono blocchi sono solo una minima parte dei nodi totali su Ethereum. Questa categoria include i nodi di mining in modalità Proof of Work (PoW) e i nodi validatori in modalità Proof of stake (PoS). Questa categoria richiede l'impegno di risorse economiche (come la potenza di hash della GPU nel Proof of Work o ETH in staking nel Proof of stake) in cambio della capacità di proporre occasionalmente il blocco successivo e ottenere le ricompense del protocollo. Gli altri nodi sulla rete (cioè, la maggioranza) non devono impegnare alcuna risorsa economica oltre a un computer di livello consumer con 1-2 TB di spazio di archiviazione disponibile e una connessione a Internet. Questi nodi non propongono blocchi, tuttavia, rivestono un ruolo critico nel proteggere la rete, considerando responsabili tutti i propositori di blocco, ascoltando nuovi blocchi e verificandone la validità all'arrivo, secondo le regole di consenso della rete. Se il blocco è valido, il nodo continua a propagarlo per la rete. Se per qualsiasi motivo il blocco non è valido, il software del nodo lo scarterà come non valido e ne interromperà la propagazione. -Eseguire un nodo che non produce blocchi è possibile per chiunque in entrambi i meccanismi di consenso (Proof of Work o Proof of stake); è _fortemente consigliato_ a tutti gli utenti che ne hanno i mezzi. Eseguire un nodo è estremamente prezioso per Ethereum e offre benefici aggiuntivi a ogni persona che ne esegue uno, come maggiore sicurezza, privacy e resistenza alla censura. +Eseguire un nodo che non produce blocchi è possibile per chiunque, in entrambi i meccanismi di consenso (proof-of-work o proof-of-stake); si vivamente consigliato a tutti gli utenti, se ne hanno i mezzi. Eseguire un nodo è estremamente prezioso per Ethereum e offre benefici aggiuntivi a ogni persona che ne esegue uno, come maggiore sicurezza, privacy e resistenza alla censura. -L'abilità per chiunque di eseguire il proprio nodo è _assolutamente essenziale_ per mantenere la decentralizzazione della rete Ethereum. +L'abilità per chiunque di gestire il proprio nodo è assolutamente essenziale per mantenere la decentralizzazione della rete di Ethereum. -[Maggiori informazione sull'esecuzione del proprio nodo](/run-a-node/) +Ulteriori informazioni sull'esecuzione di un proprio nodo + Le commissioni del gas sono un prodotto della domanda di rete relativo alla capacità della rete. La Fusione ha reso obsoleto l'uso del Proof of Work, passando al Proof of stake per il consenso, ma non ha modificato significativamente alcun parametro che influenzi direttamente la capacità o il volume di rete. -Con una [tabella di marcia incentrata sul rollup](https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698), gli sforzi si concentrano su scalare l'attività degli utenti al [livello 2](/layer-2/), abilitando allo stesso tempo la Rete principale di livello 1 come livello di accordo decentralizzato sicuro, ottimizzato per l'archiviazione dei dati di rollup per aiutare a rendere esponenzialmente più economiche le transazioni di rollup. La transizione al Proof of stake è un precursore essenziale per realizzarlo. [Di più su gas e commissioni.](/developers/docs/gas/) +Con una tabella di marcia incentrata sui rollup, gli sforzi si concentrano sul ridimensionamento delle attività degli utenti al livello 2, consentendo alla Rete Principale di Livello 1 di essere un livello di accordo decentralizzato e sicuro, ottimizzato per l'archiviazione dei dati dei rollup, per aiutare a rendere esponenzialmente più economiche le transazioni dei rollup. La transizione al Proof of stake è un precursore essenziale per realizzarlo. Ulteriori informazioni su gas e commissioni. + -Gli ETH in staking e le ricompense di staking continuano a esser bloccate, senza possibilità di prelievo. I prelievi sono pianificati per il prossimo aggiornamento di Shanghai. - +contentPreview="False, but staking withdrawals have since been enabled via the Shanghai/Capella upgrade."> - -Questo potrebbe sembrare controintuitivo rispetto alla nota precedente, ovvero che i prelievi non saranno abilitati fino all'aggiornamento di Shanghai, ma i validatori HANNO accesso immediato alle ricompense/MEV delle commissioni ottenute durante le proposte dei blocchi. +Inizialmente, dopo La Fusione, gli staker potevano accedere soltanto alle mance delle commissioni e la MEV guadagnate come conseguenza delle proposte di blocchi. Queste ricompense sono accreditate a un conto non di staking, controllato dal validatore (noto come il destinatario della commissione) e sono immediatamente disponibili. Queste ricompense sono separate dalle ricompense del protocollo, per l'esecuzione dei doveri del validatore. -Il protocollo emette ETH come una ricompensa ai validatori per aver contribuito al consenso. Il livello di consenso tiene conto degli ETH appena emessi, in cui un validatore ha un indirizzo univoco che detiene i suoi ETH in staking e le ricompense del protocollo. Questi ETH sono bloccati fino a Shanghai. +Dall'aggiornamento della rete di Shanghai/Capella, gli staker possono ora designare un indirizzo di prelievo per iniziare a ricevere pagamenti automatici di qualsiasi saldo di staking in eccesso (ETH superiori a 32, da ricompense del protocollo). Questo aggiornamento, inoltre, ha consentito la capacità di un validatore di sbloccare e rivendicare l'intero saldo all'uscita dalla rete. + +Maggiori informazioni sui prelievi in staking -Gli ETH sul livello di esecuzione sono contabilizzati separatamente dal livello di consenso. Quando gli utenti eseguono le transazioni sulla Rete Principale di Ethereum, devono esser pagati degli ETH per coprire il gas, inclusa una mancia al validatore. Questi ETH sono già sul livello di esecuzione, NON sono appena stati emessi dal protocollo e sono disponibili immediatamente al validatore (a condizione che un indirizzo `fee recipient` adatto sia fornito al software client). -Dopo che l'aggiornamento di Shanghai avrà consento i prelievi, tutti i validatori saranno incentivati a prelevare il proprio saldo di staking oltre i 32 ETH, poiché questi fondi non si aggiungono al rendimento e sono altrimenti bloccati. A seconda dell'APR (determinato dagli ETH in staking totali), potrebbero esser incentivati a uscire dai loro validatori per rivendicare il proprio saldo per intero o metterne potenzialmente in staking persino di più usando le proprie ricompense per ottenere maggiori rendimenti. +Quando l'aggiornamento di Shnanghai/Capella ha consentito i prelievi, i validatori sono stati incentivati a prelevare il proprio saldo di staking superiore a 32 ETH, poiché questi fondi non si sommano alla resa e sono altrimenti bloccati. A seconda dell'APR (determinato dagli ETH in staking totali), potrebbero esser incentivati a uscire dai loro validatori per rivendicare il proprio saldo per intero o metterne potenzialmente in staking persino di più usando le proprie ricompense per ottenere maggiori rendimenti. + +Un importante avvertimento, qui, le uscite dei validatori completi sono limitate in tasso dal protocollo e soltanto un certo numero di validatori può uscire, per ogni epoca (ogni 6,4 minuti). Questo limite fluttua a second del numero di validatori attivi, ma equivale, all'incirca, allo 0,33% degli ETH in staking totali, che possono uscire dalla rete in un singolo giorno. -Ecco un'importante avvertenza, le uscite complete dai validatori sono limitate in termini di frequenza dal protocollo, quindi solo sei validatori possono uscire per ogni epoca (ogni 6,4 minuti, quindi 1350 al giorno o solo circa 43.200 ETH al giorno degli oltre 10 milioni di ETH in staking). Questo limite di frequenza si regola a seconda degli ETH in staking totali e impedisce un esodo di massa di fondi. Inoltre, impedisce a un potenziale utente malevolo di usare il suo saldo di staking per commettere un illecito passibile di slashing e di uscire dal suo saldo di staking per intero nella stessa epoca prima che il protocollo possa applicare la sanzione di slashing. +Ciò impedisce un esodo di massa dei fondi in staking. Inoltre, previene che un potenziale utente malevolo, con accesso a una grande porzione degli ETH in staking totali, commetta un illecito passibile di slashing e prelevi per intero i saldi del validatore incriminato di staking per intero nella stessa epoca prima che il protocollo possa applicare la sanzione di slashing. -L'APR è intenzionalmente dinamico, consentendo a un mercato di staker di ponderare quanto vogliano essere pagati per contribuire a proteggere la rete. Quando i prelievi saranno abilitati, se la frequenza sarà troppo bassa, allora i validatori usciranno a una frequenza limitata dal protocollo. Questo porterà gradualmente all'aumento dell'APR per chiunque rimanga, attirando staker nuovi o di ritorno. +L'APR, inoltre, è intenzionalmente dinamico, consentendo a un mercato di staker di bilanciare quanto desiderano essere pagati per contribuire alla protezione della rete. Se il tasso è troppo basso, i validatori usciranno a un tasso limitato dal protocollo. Questo porterà gradualmente all'aumento dell'APR per chiunque rimanga, attirando staker nuovi o di ritorno. ## Cos'è successo a 'Eth2'? {#eth2} @@ -203,9 +207,9 @@ I blocchi sono invece proposti dai nodi di convalida, che ottengono ETH in staki ### La Fusione e l'aggiornamento di Shanghai {#merge-and-shanghai} -Per poter semplificare e massimizzare l'attenzione sulla riuscita della transizione al Proof of stake, l'aggiornamento de La Fusione non ha incluso alcune funzionalità annunciate, come la possibilità di prelevare gli ETH in staking. Si prevede che l'aggiornamento di Shanghai segua La Fusione, abilitando la possibilità di prelievo per gli staker. +Per poter semplificare e massimizzare l'attenzione sulla riuscita della transizione al Proof of stake, l'aggiornamento de La Fusione non ha incluso alcune funzionalità annunciate, come la possibilità di prelevare gli ETH in staking. Questa funzionalità è stata abilitata separatamente, con l'aggiornamento di Shanghai/Capella. -Rimani aggiornato sul [Problema di pianificazione dell'aggiornamento di Shanghai su GitHub](https://github.com/ethereum/pm/issues/450), o sul [Blog di Ricerca e Sviluppo dell'EF](https://blog.ethereum.org/category/research-and-development/). Per i curiosi, scoprite di più su [Cosa succede dopo la Fusione](https://youtu.be/7ggwLccuN5s?t=101), presentato da Vitalik all'evento ETHGlobal di aprile 2021. +Per i curiosi, scoprite di più su [Cosa succede dopo la Fusione](https://youtu.be/7ggwLccuN5s?t=101), presentato da Vitalik all'evento ETHGlobal di aprile 2021. ### La Fusione e lo sharding {#merge-and-data-sharding} diff --git a/src/content/translations/it/roadmap/merge/issuance/index.md b/src/content/translations/it/roadmap/merge/issuance/index.md new file mode 100644 index 00000000000..5c102d06e26 --- /dev/null +++ b/src/content/translations/it/roadmap/merge/issuance/index.md @@ -0,0 +1,134 @@ +--- +title: In che modo La Fusione ha influenzato l'offerta di ETH +description: Analisi dell'impatto de La Fusione sull'offerta di ETH +lang: it +--- + +# In che modo La Fusione ha influenzato l'offerta di ETH {#how-the-merge-impacts-ETH-supply} + +La Fusione ha rappresentato la transizione delle reti di Ethereum dal proof-of-work al proof-of-stake, verificatasi a settembre 2022. Il metodo di emissione degli ETH ha subito delle modifiche al momento di tale transizione. Precedentemente, i nuovi ETH erano emessi da due fonti: il livello d'esecuzione (cioè la Rete Principale) e il livello di consenso (cioè La Beacon Chain). Da La Fusione, l'emissione sul livello d'esecuzione è ora pari a zero. Analizziamolo. + +## Componenti dell'emissione di ETH {#components-of-eth-issuance} + +Possiamo spezzare la fornitura di ETH in due forze principali: emissione e bruciatura. + +L'**emissione** di ETH è il procedimento di creazione di ETH, che precedentemente non esisteva. La **bruciatura** di ETH è quando gli ETH esistenti vengono distrutti, rimuovendoli dalla circolazione. Il tasso di emissione e bruciatura viene calcolato su diversi parametri e, il saldo tra di essi, determina il tasso di inflazione/deflazione di ether risultante. + + + +- Prima di passare al proof of stake, i miner emettevano approssimativamente 13.000ETH/giorno +- Gli staker emettono approssimativamente 1.700 ETH/giorno, sulla base di un totale di circa 14 milioni di ETH in staking +- L'emissione di staking esatta fluttua a seconda dell'importo totale di ETH in staking +- **Da La Fusione, restano approssimativamnte soltanto 1.700 ETH/giorno, riducendo la nuova emissione totale di ETH di circa l'88%** +- La bruciatura: questa, fluttua secondo la domanda di rete. _Se_ per un dato giorno si osserva un prezzo di gas medio di almeno 16 gwei, questo compensa effettivamente i circa 1.700 ETH emessi ai validatori e porta l'inflazione netta di ETH a zero, o meno, per quel giorno. + + + +## Pre-Fusione (storico) {#pre-merge} + +### Emissione del livello d'esecuzione {#el-issuance-pre-merge} + +Sotto il proof of work, i miner interagivano soltanto con il livello d'esecuzione, venendo ricompensati con ricompense dei blocchi, se erano i primi a risolvere il blocco successivo. Dall'[aggiornamento di Costantinopoli](/history/#constantinople) nel 2019, questa ricompensa era di 2 ETH per blocco. I miner, inoltre, erano ricompensati per la pubblicazione di blocchi [ommer](/glossary/#ommer), blocchi validi che non finivano nella catena più lunga/canonica. Queste ricompense erano massimizzate a 1,75 ETH per ommer ed erano _da sommarsi_ alla ricompensa emessa dal blocco canonico. Il processo di mining era un'attività economicamente intensiva che, storicamente, richiedeva elevati livelli di emissione di ETH per essere sostenuta. + +### Emissione del livello del consenso {#cl-issuance-pre-merge} + +La [Beacon Chain](/history/#beacon-chain-genesis) è stata attivata nel 2020. Invece dei miner, è protetta dai validatori, che utilizzano il proof of stake. Questa catena è stata avviata dagli utenti di Ethereum, che depositavano ETH a senso unico in uno smart contract sulla Rete Principale (il livello d'esecuzione), ascoltato dalla Beacon Chain, accreditando l'utente con un importo equivalente di ETH, sulla nuova catena. Fino alla Fusione, i validatori della Beacon Chain non stavano elaborando le transazioni e, fondamentalmente, arrivavano al consenso sullo stato dello stesso gruppo di validatori. + +I validatori sulla Beacon Chain sono ricompensati con ETH per l'attestazione allo stato della catena e la proposta di blocchi. Le ricompense (o penalità) sono calcolate e distribuite a ogni epoca (ogni 6,4 minuti) a seconda delle prestazioni del validatore. Le ricompense del validatore sono **significativamente** inferiori a quelle di mining, emesse precedentemente sotto il proof-of-work (pari a 2 ETH circa ogni 13,5 secondi), poiché l'operazione di un nodo di convalida non è altrettanto intenso dal punto di vista economico e quindi non richiede né garantisce una ricompensa altrettanto elevata. + +### Analisi sulle emissioni pre-Fusione {#pre-merge-issuance-breakdown} + +Offerta totale di ETH: **circa 120.520.000 ETH** (al momento della Fusione a settembre 2022) + +**Emissione del livello d'esecuzione:** + +- Era stimata a 2,08 ETH ogni 13,3 secondi\*: **circa 4.930.000** ETH emessi in un anno +- Il risultato è un tasso d'inflazione **di circa il 4,09%** (4,93M l'anno / 120,5M totali) +- \*Ciò include i 2 ETH per blocco canonico, più una media di 0,08 ETH nel tempo dai blocchi ommer. Inoltre, utilizza 13,3 secondi, l'obiettivo temporale di base del blocco senza alcuna influenza da una [bomba di difficoltà](/glossary/#difficulty-bomb). ([Vedi fonte](https://bitinfocharts.com/ethereum/)) + +**Emissione del livello d'esecuzione:** + +- Utilizzando i 14.000.000 di ETH totali in staking, il tasso di emissione di ETH è approssimativamente di 1700 ETH/giorno ([Vedi fonte](https://ultrasound.money/)) +- Il risultato è **circa 620.500** ETH emessi in un anno +- Il risultato è un tasso d'inflazione **approssimativamente dello 0,52%** (620.5K l'anno / 119.3M totali) + + +Tasso di emissione annualizzato totale (pre-Fusione): circa 4,61% (4,09% + 0,52%)

+Circa l'88,7% dell'emissione andava ai miner sul livello d'esecuzione (4,09 / 4,61 * 100)

+Circa l'11,3% era emesso agli staker sul livello del consenso (0,52 / 4,61 * 100) + + +## Post-Fusione (oggi) {#post-merge} + +### Emissione del livello d'esecuzione {#el-issuance-post-merge} + +L'emissione del livello d'esecuzione dalla Fusione è pari a zero. Il proof-of-work non è più un mezzo valido per la produzione di blocchi, secondo le regole aggiornate del consenso. Tutta l'attività del livello d'esecuzione è impacchettata nei "blocchi della Beacon", pubblicati e attestati dai validatori del proof-of-stake. Le ricompense per l'attestazione e pubblicazione dei blocchi della Beacon sono considerate separatamente sul livello del consenso. + +### Emissione del livello del consenso {#cl-issuance-post-merge} + +L'emissione del livello di consenso continua ad oggi, così come prima della Fusione, con piccole ricompense per i validtori che attestano a e propongono i blocchi. Le ricompense dei validatori continuano a maturare ai _saldi dei validatori_, gestiti nel livello del consenso. A differenza dei conti correnti (conti di "esecuzione"), che possono effettuare transazioni sulla Rete Principale, questi conti separati di Ethereum non possono operare liberamente con altri conti di Ethereum. I fondi in questi conti sono prelevabili esclusivamente a un singolo indirizzo d'esecuzione specificato. + +Dall'aggiornamento di Shanghai/Capella, avvenuto ad aprile 2023, questi prelievi sono stati consentiti per gli staker. Gli staker sono incentivati a rimuovere i propri _guadagni/ricompense (per saldi superiori a 32 ETH)_, poiché, tali fondi non contribuirebbero altrimenti al loro peso di staking (che si massimizza a 32 ETH). + +Gli staker, inoltre, potrebbero scegliere di uscire e prelevare l'intero saldo del loro validatore. Per assicurare la stabilità di Ethereum, il numero di validatori in uscita simultanea è limitato. + +Approssimativamente lo 0,33% del conteggio totale dei validatori può uscire in un dato giorno. Di default, possono uscire quattro (4) validatori per epoca (ogni 6,4 minuti, o 900 al giorno). Un (1) validatore aggiuntivo può uscire per ogni 65.536 (216) validatori aggiuntivi su 262.144 (218). Ad esempio, con oltre 327.680 validatori, potrebbero uscirne cinque (5) per epoca (1.125 al giorno). Sei (6) sarebbero autorizzati con un conteggio di validatori attivi totali superiore a 393.216 e così via. + +All'aumentare del numero di validatori che prelevano, il numero massimo di validatori in uscita sarà ridotto gradualmente a un minimo di quattro, per evitare intenzionalmente che vengano prelevati contemporaneament egrandi quantitativi destabilizzanti di ETH in staking. + +### Analisi dell'inflazione post-Fusione {#post-merge-inflation-breakdown} + +- Offerta totale di ETH: **circa 120.520.000 ETH** (al momento della Fusione a settembre 2022) +- Emissione del livello d'esecuzione: **0** +- Emissione del livello di consenso: come sopra, tasso di emissione annualizzato **approssimativo dello 0,52%** (con 14 milioni di ETH in staking totali) + + +Tasso di emissione annualizzato totale: circa 0,52%

+Riduzione netta nell'emissione annuale di ETH: circa 88,7% ((4,61%-0,52%) / 4,61% * 100) + + +## La bruciatura {#the-burn} + +La forza opposta all'emissione di ETH è il tasso a cui gli ETH sono bruciati. Per l'esecuzione di una transazione su Ethereum, dev'essere pagata una commissione minima (nota come "commissione di base"), che fluttua continuamente (da blocco a blocco), a seconda dell'attività di rete. La commissione è pagata in ETH ed è _necessaria_ affinché la transazione sia considerata valida. Questa commissione viene _bruciata_ durante il procedimento della transazione, rimuovendola dalla circolazione. + + +La bruciatura delle commissioni è divenuta attiva con l'aggiornamento di Londra ad agosto 2021 e resta immutata da La Fusione. + + +Oltre alla bruciatura della commissione, implementata dall'aggiornamento di Londra, i validatori, inoltre, possono incorrere in sanzioni per essere online o, peggio, possono ricevere tagli per l'infrazione di regole specifiche che minacciano la sicurezza della rete. Queste, risultano in una riduzione degli ETH dal saldo di quel validatore, che non è ricompensato direttamente a nessun altro conto, bruciandoli/rimuovendoli effettivamente dalla circolazione. + +### Calcolare il prezzo medio del gas per la deflazione {#calculating-average-gas-price-for-deflation} + +Come discusso sopra, l'importo di ETH emessi in un dato giorno dipende dagli ETH in staking totali. Al momento della scrittura, questo equivale a circa 1700 ETH/giorno. + +Per determinare il prezzo medio del gas necessario a compensare completamente tale emissione in un dato periodo di 24 ore, inizieremo calcolando il numero totale di blocchi in un giorno, dato il tempo di un blocco di 12 secondi: + +- `(1 blocco / 12 secondi) * (60 secondi/minuto) = 5 blocchi/minuto` +- `(5 blocchi/minuto) * (60 minuti/ora) = 300 blocchi/ora` +- `(300 blocchi/ora) * (24 ore/giorno) = 7200 blocchi/giorno` + +Ogni blocco indirizza `15x10^6 gas/blocco` ([di più sul gas](/developers/docs/gas/)). Utilizzandolo, possiamo risolvere per il prezzo medio del gas (in unità di gwei/gas), necessario per compensare l'emissione, data un'emissione totale giornaliera di 1700 ETH: + +- `7200 blocchi/giorno * 15x10^6 gas/blocco *`**`Y gwei/gas`**`* 1 ETH/ 10^9 gwei = 1700 ETH/giorno` + +Risolvendo per `Y`: + +- `Y = (1700(10^9))/(7200 * 15(10^6)) = (17x10^3)/(72 * 15) = 16 gwei` (arrotondando soltanto alle due cifre significative) + +Un altro metodo per riorganizzare questo ultimo passaggio sarebbe sostituire `1700` con una variabile `X` che rappresenti l'emissione giornaliera di ETH e semplificare il resto a: + +- `Y = (X(10^3)/(7200 * 15)) = X/108` + +Possiamo semplificarlo e scriverlo come una funzione di `X`: + +- `f(X) = X/108` dove `X` è l'emissione giornaliera di ETH, e `f(X)` rappresenta il prezzo di gwei/gas necessario per compensare tutti i nuovi ETH emessi. + +Quindi, ad esempio, se `X` (emissione giornaliera di ETH) sale a 1800 secondo gli ETH totali in staking, `f(X)` (gwei necessari per compensare tutta l'emissione) sarebbe `17 gwei` (utilizzando le 2 cifre significative) + +## Ulteriori letture {#further-reading} + +- [La fusione](/roadmap/merge/) +- [Ultrasound.money](https://ultrasound.money/) - _Pannelli di controllo disponibili per visualizzare l'emissione e la bruciatura di ETH in tempo reale_ +- [Rilevare l'Emissione di Ethereum](https://www.attestant.io/posts/charting-ethereum-issuance/) - _Jim McDonald 2020_ diff --git a/src/content/translations/it/roadmap/pbs/index.md b/src/content/translations/it/roadmap/pbs/index.md new file mode 100644 index 00000000000..7c9f91e7123 --- /dev/null +++ b/src/content/translations/it/roadmap/pbs/index.md @@ -0,0 +1,51 @@ +--- +title: Separazione proponente-sviluppatore +description: Scopri come e perché i validatori di Ethereum divideranno le proprie responsabilità di costruzione e trasmissione dei blocchi. +lang: it +--- + +# Separazione proponente-sviluppatore {#proposer-builder-separation} + +I validatori odierni di Ethereum creano _e_ trasmettono i blocchi. Raggruppano le transazioni che hanno sentito nella rete di gossip e le impacchettano in un blocco, inviato ai pari sulla rete di Ethereum. La **separazione tra propositore e costruttore (PBS)** divide queste mansioni tra più validatori. I costruttori di blocchi diventano responsabili della creazione dei blocchi e li offrono al propositore di blocchi, in ogni spazio. Il propositore di blocchi non può visualizzare i contenuti del blocco, semplicemente, sceglie il più profittevole, pagando una commissione al suo costruttore, prima di inviarlo i suoi pari. + +Questo è un aggiornamento importante per svariati motivi. Primo, crea opportunità per prevenire la censura delle transazioni al livello del protocollo. Secondo, impedisce ai validatori hobbisti di essere "battuti" dalla concorrenza di utenti istituzionali, che possono meglio ottimizzare la redditività della costruzione del proprio blocco. Terzo, aiuta a ridimensionare Ethereum, consentendo gli aggiornamenti di Danksharding. + +## PBS e resistenza alla censura {#pbs-and-censorship-resistance} + +La separazione dei costruttori e propositori di blocchi complica per i costruttori di blocchi la censura delle transazioni. Questo perché, dei criteri di inclusione relativamente complessi possono essere aggiunti, assicurando che non avvenga alcuna censura, prima della proposta del blocco. Poiché il propositore di blocchi è un'entità separata dal costruttore di blocchi, può assumere il ruolo di protettore, contro la censura dei costruttori di blocchi. + +Ad esempio, possono essere introdotti degli elenchi di inclusione, così che quando i validatori entrano a conoscenza delle transazioni ma non le vedono incluse nei blocchi, possono imporle come necessarie nel blocco successivo. L'elenco di inclusione è generato dal mempool locale dei propositori di blocchi (l'elenco di transazioni di cui sono a conoscenza) ed è inviato ai loro pari, poco prima che un blocco sia proposto. Se una delle transazioni dall'elenco di inclusione è mancante, il propositore potrebbe rifiutare il blocco, aggiungere le transazioni mancanti prima di proporle o proporle e far sì che siano rifiutate dagli altri validatori, quando la ricevono. Inoltre, esiste una versione potenzialmente più efficiente di questa idea, che afferma che i costruttori devono utilizzare completamente lo spazio disponibile del blocco e, altrimenti, le transazioni sono aggiunte dall'elenco di inclusione del propositore. Questa è ancora un'area di ricerca attiva e la configurazione ottimale per gli elenchi di inclusione non è ancora stata determinata. + +I [mempool crittografati](https://www.youtube.com/watch?v=fHDjgFcha0M&list=PLpktWkixc1gUqkyc1-iE6TT0RWQTBJELe&index=3), inoltre, potrebbero rendere impossibile per costruttori e propositori, sapere quali transazioni stiano includendo in un blocco, dopo che questo è già stato trasmesso. + + + +Potenti organizzazioni possono spingere i validatori a censurare le transazioni da o verso certi indirizzi. I validatori si conformano alla sollecitazione, rilevando gli indirizzi nella blacklist nel gruppo di transazioni e omettendole dai blocchi che propongono. Dopo la PBS, non sarà più possibile poiché i propositori di blocchi non sapranno quali transazioni stanno trasmettendo nei propri blocchi. Potrebbe essere importante, per certi individui o app, conformarsi alle regole di censura, ad esempio, quando è emanata una legge nella loro regione. In tali casi, la conformità si verifica a livello di applicazione, mentre il protocolo rimane privo di permessi e di censura. + + + +## PBS e MEV {#pbs-and-mev} + +Il **Valore Massimo Estraibile (MEV)** fa riferimento ai validatori che massimizzano la propria redditività, ordinando favorevolmente le transazioni. Esempi comuni includono gli scambi di arbitraggio sulle piattaforme di scambio decentralizzate (es. frontrunning di una grande vendita o un grande acquisto) o identificazione di opportunità per liquidare posizioni della DeFi. La massimizzazione del MEV richiede conoscenze tecniche sofisticate e software personalizzati aggiunti ai normali validatori, rendendo più probabile che gli operatori istituzionali surclassino i validatori individuali e hobbisti all'estrazione del MEV. Ciò significa che i rendimenti da staking potrebbero essere maggiori con operatori centralizzati, creando una forza centralizzante che disincentiva lo staking domestico. + +La PBS risolve questo problema, riconfigurando l'economia del MEV. Invece del propositore di blocchi che svolge la propria ricerca del MEV seleziona semplicement eun blocco fra i tanti che gli vengono offerti dai costruttori di blocchi. I costruttori di blocchi potrebbero aver compiuto una sofisticata estrazione del MEV, ma la ricompensa va al propositore di blocchi. Ciò significa che, anche se un piccolo gruppo di costruttori di blocchi specializzati domina l'estrazione del MEV, la ricompensa potrebbe andare a qualsiasi validatore sulla rete, inclusi gli staker domestici in solo. + + + +Gli individui potrebbero essere incentivati a mettere in staking in gruppo, piuttosto che per conto proprio, grazie alle ricompense migliorate, offerte dalle sofisticate strategie di MEV. La separazione della costruzione e proposta dei blocchi significa che il MEV estratto sarà distribuito su più validatori, piuttosto che centralizzato con il ricercatore di MEV più efficiente. Al contempo, consentire ai costruttori di blocchi specializzati di esistere prende l'onere di costruzione dei blocchi dai singoli individui, impededendo ai singoli di rubare il MEV per se stessi, pur massimizzando il numero di validatori individuali e indipendenti, che possono verificare che i blocchi siano onesti. Il concetto importante è la "asimmetria tra dimostratore e verificatore", che fa riferimento all'idea che la produzione centralizzata dei blocchi vada bene, finché è una rete di validatori robusta e massimamente decentralizzata, capace di provare che i blocchi sono onesti. La decentralizzazione è un mezzo, non un obiettivo finale; ciò che vogliamo sono blocchi onesti. + + +## PBS e Danksharding {#pbs-and-danksharding} + +Il danksharding è come Ethereum si ridimensionerà a circa 100.000 transazioni al seecondo e minimizzerà le commissioni per gli utenti dei rollup. Si affida alla PBS poiché si somma al carico di lavoro per i costruttori di blocchi, che dovranno calcolare prove fino a 64MB dei dati di rollup, in meno di 1 secondo. Ciò probabilmente richiederà costruttori specializzati, che possano dedicare hardware importanti a questa attività. Tuttavia, nella situazione corrente, la costruzione dei blocchi potrebbe divenire sempre più centralizzata, con operatori più sofisticati e potenti, grazie all'estrazione del MEV. La separazione tra propositori e costruttori è un modo per abbracciare tale realtà, impedendogli di esercitare una forza centrale sulla validazione dei blocchi (la parte importante) o sulla distribuzione delle ricompense di staking. Un ottimo beneficio collaterale è che i costruttori di blocchi specializzati sono anche disposti e capaci di calcolare le prove di dati necessarie per il Danksharding. + +## Stato attuale {#current-progress} + +La PBS è in una fase di ricerca avanzata, ma esistono ancora delle importanti domande di design che devono essere risolte prima che possa essere prototipata nei client di Ethereum. Non esistono ancora delle specifiche finalizzate. Ciò significa che la PBS potrebbe ancora richiedere qualche anno. Consulta lo [stato della ricerca](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance) più recente. + +## Letture consigliate {#further-reading} + +- [Stato della ricerca: resistenza alla censura sotto PBS](https://notes.ethereum.org/@vbuterin/pbs_censorship_resistance) +- [Design di mercato delle commissioni pratici per PBS](https://ethresear.ch/t/proposer-block-builder-separation-friendly-fee-market-designs/9725) +- [PBS e resistenza alla censura](https://notes.ethereum.org/@fradamt/H1TsYRfJc#Secondary-auctions) +- [Elenchi di inclusione](https://notes.ethereum.org/@fradamt/H1ZqdtrBF) diff --git a/src/content/translations/it/roadmap/scaling/index.md b/src/content/translations/it/roadmap/scaling/index.md new file mode 100644 index 00000000000..9e37af0687c --- /dev/null +++ b/src/content/translations/it/roadmap/scaling/index.md @@ -0,0 +1,47 @@ +--- +title: Ridimensionare Ethereum +description: I rollup raggruppano le transazioni al di fuori della catena, riducendo i costi per l'utente. Tuttavia, il metodo con cui i rollup utilizzano i dati al momento è troppo costoso e questo limita l'economicità delle transazioni. Il Proto-Danksharding lo corregge. +lang: it +image: ../../../../../assets/roadmap/roadmap-transactions.png +alt: "Roadmap di Ethereum" +template: roadmap +--- + +Ethereum è ridimensionato utilizzando i [livelli 2](/layer-2/#rollups) (anche noti come rollup), che raggruppano le transazioni, inviando il risultato a Ethereum. Sebbene i rollup siano fino a otto volte meno costosi che sulla Rete Principale di Ethereum, è possibile ottimizzare ulteriormente i rollup per ridurre i costi per gli utenti finali. Inoltre, i rollup, si affidano ad alcuni componenti centralizzati che gli sviluppatori possono rimuovere, al maturare dei rollup. + + +
    +
  • I rollup odierni sono all'incirca da 3 a 8 volte più economici del livello 1
    • +
  • I rollup ZK ridurranno presto le commissioni di circa da 40 a 100 volte
    • +
  • I cambiamenti in arrivo su Ethereum forniranno un ulteriore ridimensionamento di circa 100-1000 volte
    • +
  • Gli utenti dovrebbero beneficiare dalle transazioni dal costo inferiore a $0,001
    • +
+ + +## Rendere più economici i dati {#making-data-cheaper} + +I rollup raccolgono grandi numeri di transazioni, le eseguono e poi inviano i risultati a Ethereum. Ciò genera molti dati che devono essere disponibili apertamente, così che tutti possano eseguire le transazioni da soli, verificando che l'operatore del rollup sia onesto. Se qualcuno trova una discrepanza, può generare una sfida. + +### Proto-Danksharding {#proto-danksharding} + +I dati dei rollup sono memorizzati permanentemente su Ethereum, il che può essere costoso. Oltre il 90% dei costi di transazione pagati sui rollup è causato da tale archiviazione dei dati. Per ridurre i costi di transazione, possiamo spostare i dati in una nuova archiviazione temporanea a 'blob'. I blob sono più economici poiché non sono permanenti; sono eliminati da Ethereum una volta che non sono più necessari. Archiviare i dati dei rollup a lungo termine diviene la responsabilità delle persone che lo necessitano, come gli operatori dei rollup, le piattaforme di scambio, i servizi di indicizzazione, ecc. Aggiungere le transazioni di blob a Ethereum è parte di un aggiornamento noto come "Proto-Danksharding". La sua distribuzione dovrebbe avvenire in tempi relativamente brevi, forse verso la fine del 2023. + +Dopo che le transazionidia blob saranno divenute parte del protocollo di Ethereum tramite il Proto-Danksharding, sarà possibile aggiungere molti blob ai blocchi di Ethereum. Questo sarà un altro ridimensionamento sostanziale (di circa 100 volte) del volume di Ethereum e riduzione dei costi di transazione. + +### Danksharding {#danksharding} + +La seconda fase dell'espansione dei dati di blob è complicata poiché richiede nuovi metodi di verifica dei dati di rollup disponibili sulla rete e si affida alla separazione, da parte dei validatori, delle proprie responsabilità di costruzione e proposta dei blocchi. Inoltre, richiede un metodo per provare crittograficamente che i validatori abbiano verificato piccoli sotto nsiemi dei dati dei blob. + +Questa seconda fase è nota come [“Danksharding”](/roadmap/danksharding/). Probabilmente, trascorreranno diversi anni prima della sua completa implementazione. Il danksharding si affida ad altri sviluppi come la [separazione della costruzione e della proposta dei blocchi](/roadmap/pbs) e nuovi design della rete che consentano a essa di confermare efficientemente che i dati siano disponibili, campionando casualmente pochi kilobyte per volta, procedimento noto come [campionamento della disponibilità dei dati (o DAS)](/developers/docs/data-availability). + +Di più sul Danksharding + +## Decentralizzare i rollup {#decentralizing-rollups} + +I [rollup](/layer-2) stanno già ridimensionando Ethereum. Un [ecosistema ricco di progetti di rollup](https://l2beat.com/scaling/tvl) sta consentendo agli utenti di eseguire le transazioni rapidamente ed economicamente, con numerose garanzie di sicurezza. Tuttavia, i rollup sono stati avviati utilizzando sequenziatori centralizzati (computer che eseguono tutta l'elaborazione e aggregazione delle transazioni, prima di inviarle a Ethereum). Ciò è vulnerabile alla censura, poiché gli operatori del sequenziatore sono sanzionabili, corrompibili o, compromessi in altri modi. Al contempo, i [rollup variano](https://l2beat.com) nel modo in cui convalidano i dati in entrata. Il metodo migliore è che i "dimostratori" inviino prove di frode o prove di validità, ma non tutti i rollup sono ancora a quel punto. Persino quei rollup che utilizzano le prove di validità/frode, utilizzano un piccolo gruppo di dimostratori noti. Dunque, il prossimo passaggio critico nel ridimensionare Ethereum è distribuire la responsabilità di operare i sequenziatori e i dimostratori, tra più persone. + +Maggiori informazioni sui rollup + +## Stato attuale {#current-progress} + +Il Proto-Danksharding potrebbe essere uno dei primi punti della tabella di marcia da implementare. I passaggi di calcolo decentralizzati richiesti per configurarlo sono già in lavorazione e, diversi client, hanno implementato dei prototipi per gestire i dati dei blob. Il Danksharding completo richiederà probabilmente ancora diversi anni, poiché si affida su diversi altri punti della tabella di marcia, ancora da completare. La decentralizzazione dell'infrastruttura dei rollup è probabilmente un processo graduale: esistono molti rollup differenti che stanno creando sistemi lievemente differenti e si decentralizzeranno completamente a velocità diverse. diff --git a/src/content/translations/it/roadmap/secret-leader-election/index.md b/src/content/translations/it/roadmap/secret-leader-election/index.md new file mode 100644 index 00000000000..36ef1aad78d --- /dev/null +++ b/src/content/translations/it/roadmap/secret-leader-election/index.md @@ -0,0 +1,44 @@ +--- +title: Elezioni segrete del leader +description: Spiegazione di come l'elezione segreta di un capo possa aiutare a proteggere i validatori dagli attacchi +lang: it +summaryPoints: + - L'indirizzo IP dei propositori di blocchi può essere noto in anticipo, rendendoli vulnerabili agli attacchi + - L'elezione segreta del capo nasconde l'identità dei validatori, così che non possano essere conosciuti in anticipo + - Un'estensione di quest'idea è rendere casuale la selezione del validatore, per ogni spazio. +--- + +# Elezioni segrete del leader {#single-secret-leader-election} + +Nel meccanismo di consenso odierno basato sul [proof-of-stake](/developers/docs/consensus-mechanisms/pos), l'elenco di propositori di blocchi in entrata è pubblico ed è possibile mapparne gli indirizzi IP. Ciò significa che gli utenti malevoli potrebbero identificare quali valori dovrebbero proporre a un blocco e li prendono di mira con un attacco di negazione del servizio (DOS), che li lascia incapaci di proporre il proprio blocco in tempo. + +Questo potrebbe creare opportunità di profitto per un utente malevolo. Ad esempio, un propositore di blocchi selezionato per lo spazio `n+1` potrebbe compiere un attacco DOS nei confronti del propositore allo spazio `n`, così che perda l'opportunità di proporre un blocco. Questo consentirebbe al propositore di blocchi che attacca di estrarre il MEV da entrambi gli slot, o di prendere tutte le transazioni che dovrebbero essere divise tra i due blocchi e invece includerli tutti in una volta, ottenendo tutte le commissioni associate. Questo potrebbe influenzare i validatori domestici più di quelli istituzionali sofisticati, che possono utilizzare metodi più avanzati per proteggersi dagli attacchi DOS e, dunque, potrebbero essere una forza centralizzante. + +Esistono svariate soluzioni a questo problema. Una è la [Tecnologia del Validatore Distribuita](https://github.com/ethereum/distributed-validator-specs), che mira a diffondere le varie mansioni correlate all'operazione di un validatore tra più macchine, con ridondanza, così che sia molto più complicato, per un utente malevolo, prevenire la proposta di un blocco in uno slot particolare. Tuttavia, la soluzione più robusta è l'**Elezione Segreta di un Singolo Capo (SSLE)**. + +## Elezione segreta di un singolo capo {#secret-leader-election} + +Nella SSLE, si utilizza una crittografia intelligente per assicurarsi che soltanto il validatore selezionato sappia di esser stato selezionato. Ciò funziona facendo inviare a ogni validatore un impegno a una frase segreta condivisa. Gli impegni sono mescolati e riconfigurati così che nessuno possa mapparli ai validatori, ma che ogni validatore sa quale gli appartiene. Poi, si sceglie un impegno a caso. Se un validatore rileva che è stato scelto il proprio impegno, sa che è il suo turno di proporre un blocco. + +L'implementazione principale di quest'idea si chiama [Whisk](https://ethresear.ch/t/whisk-a-practical-shuffle-based-ssle-protocol-for-ethereum/11763). Che funziona come segue: + +1. I validatori si impegnano a una frase segreta condivisa. Lo schema di impegno è progettato così che possa essere vincolato all'identità di un validatore, nonché casualizzato, così che nessuna terza parte possa decodificarlo e collegare un impegno specifico a un validatore specifico. +2. All'inizio di un'epoca, una serie casuale di validatori è scelta per campionare gli impegni da 16.384 validatori, utilizzando RANDAO. +3. Per i prossimi 8182 spazi (1 giorno), i propositori di blocchi mescolano e randomizzano un sottoinsieme di impegni, utilizzando la propria entropia privata. +4. Dopo il termine del rimescolamento, RANDAO è utilizzato per creare un elenco ordinato di impegni. Questo elenco è mappato agli spazi di Ethereum. +5. I validatori vedono che il proprio impegno è collegato a uno spazio specifico e, quando quello spazio arriva, propongono un blocco. +6. Questi passaggi si ripetono così che l'assegnazione degli impegni agli spazi sia sempre di molto in avanti rispetto allo spazio corrente. + +Questo impedisce agli utenti malevolo di sapere in anticipo quale validatore nello specifico proporrà il prossimo blocco, impedendo l'abilità di compiere attacchi DOS. + +## Elezione segreta di un capo non singolo (SnSLE) {#secret-non-single-leader-election} + +Inoltre, esiste una proposta separata che mira a creare uno scenario in cui ogni validatore ha una possibilità casuale di proporre un blocco in ogni spazio, similmente a come la proposta del blocco era decisa sotto proof-of-work, nota come **elezione segreta di un capo non singolo (SnSLE)**. Un metodo semplice per compierla è utilizzare la funzione RANDAO per selezionare casualmente i validatori nel protocollo di oggi. L'idea con RANDAO è che un numero sufficientemente casuale è generato, mischiando gli hash inviati da molti validatori indipendenti. Nella SnSLE, questi hash potrebbero essere utilizzati per scegliere il propositore di blocchi successivo, ad esempio, scegliendo l'hash dal valore più basso. L'intervallo di hash validi potrebbe essere limitato, per sintonizzarsi alla probabilità che siano selezionati dei validatori singoli in ogni spazio. Affermando che l'hash dev'essere inferiore a `2^256 * 5 / N`, dove `N` è il numero di validatori attivi, la possibilità che ogni singolo validatore sia selezionato in ogni spazio sarebbe di `5/N`. In qusto esempio, esisterebbe una probabilità del 99,3% che almeno un propositore generi un hash valido in ogni spazio. + +## Stato attuale {#current-progress} + +SSLE e SnSLE sono entrambi in fase di ricerca. Ancora non esiste una specifica finalizzata per alcuna delle due idee. SSLE e SnSLE sono proposte concorrenti che potrebbero entrambe non essere implementate. Prima di distribuirle, necessitano di ulteriore ricerca e sviluppo, prototipazione e implementazione sulle reti di prova pubbliche. + +## Letture consigliate {#further-reading} + +- [SnSLE](https://ethresear.ch/t/secret-non-single-leader-election/11789) diff --git a/src/content/translations/it/roadmap/security/index.md b/src/content/translations/it/roadmap/security/index.md new file mode 100644 index 00000000000..e0e213fde70 --- /dev/null +++ b/src/content/translations/it/roadmap/security/index.md @@ -0,0 +1,48 @@ +--- +title: Un Ethereum più sicuro +description: Ethereum è la piattaforma di contratti intelligenti più sicura e decentralizzata che esista. Tuttavia, restano ancora da implementare alcuni miglioramenti in modo che Ethereum resti resiliente a qualsiasi livello di attacco anche in un futuro lontano. +lang: it +image: ../../../../../assets/roadmap/roadmap-security.png +alt: "Roadmap di Ethereum" +template: roadmap +--- + +Ethereum è già una piattaforma di contratti intelligenti molto sicura e decentralizzata. Tuttavia, restano ancora da implementare alcuni miglioramenti in modo che Ethereum resti resiliente a qualsiasi tipo di attacco anche in un futuro lontano. Questi, includono lievi modifiche a come i client di Ethereum affrontano i blocchi in competizione, nonché aumentare come la velocità di rete considera i blocchi ["finalizzati"](/developers/docs/consensus-mechanisms/pos/#finality) (a significare che non sono modificabili senza estreme perdite economiche da parte di un utente malevolo). + +Esistono anche dei miglioramenti che complicano la censura delle transazioni, rendendo i propositori di blocchi ciechi ai contenuti effettivi dei propri blocchi, e nuovi modi per identificare quando un client sta censurando. Insieme, questi miglioramenti aggiorneranno il protocollo di proof-of-stake, così che gli utenti, singoli e aziendali, abbiano l'istantanea fiducia nelle proprie app, nei propri dati e risorse su Ethereum. + +## Prelievi di staking {#staking-withdrawals} + +L'aggiornamento dal proof-of-work al proof-of-stake è iniziato quando i pionieri di Ethereum hanno messo in "staking" i propri ETH in un contratto di deposito. Tali ETH sono utilizzati per proteggere la rete. Tuttavia, questi ETH non sono ancora sbloccabili e restituibili agli utenti. Consentire agli ETH di essere prelevati è una parte critica dell'aggiornamento del proof-of-stake. Oltre ai prelievi, che sono un componente fondamentale di un protocollo di proof-of-stake pienamente funzionale, consentire i prelievi è un bene anche per la sicurezza di Ethereum, poiché consentono agli staker di utilizzare le proprie ricompense in ETH per altri scopi non di staking. Ciò significa che gli utenti che desiderano liquidità non debbano affidarsi ai derivati liquidi di staking (LSD), che possono essere una forza centralizzante su Ethereum. Si prevede che questo aggiornamento sarà completato il 12 aprile 2023. + +Informazioni sui prelievi + +## Difendersi dagli attacchi {#defending-against-attacks} + +Esistono dei miglioramenti apportabili al protocollo di [proof-of-stake](/developers/docs/consensus-mechanisms/pos/) di Ethereum che vanno oltre i prelievi. Uno è noto come [view-merge](https://ethresear.ch/t/view-merge-as-a-replacement-for-proposer-boost/13739), un algoritmo di scelta della biforcazione più sicuro, che complica certi tipi di attacchi più sofisticati. + +Ridurre il tempo di finalizzazione dei blocchi di Ethereum, fornirebbe una migliore esperienza agli utenti e impedirebbe i sofisticati attacchi di "riorganizzazione", in cui gli utenti malevoli provano a rimescolare i blocchi molto recenti, per estrarre profitto o censurare certe transazioni. La [**finalità dello spazio singolo (SSF)**](/roadmap/single-slot-finality/) è un metodo per ridurre il ritardo di finalizzazione. In questo momento, esistono 15 minuti di blocchi, che un utente malevolo potrebbe teoricamente convincere altri validatori a riconfigurare. Con la SSF, ce ne sono 0. Gli utenti, dagli individui alle app e le piattaforme di scambio, beneficiano dalla veloce garanzia che le proprie transazioni non saranno ripristinate, e la rete ne beneficia arrestando un'intera classe di attacchi. + +Informazioni sulla finalità dello spazio singolo + +## Difendersi dalla censura {#defending-against-censorship} + +La decentralizzazione impedisce che validatori singoli o in piccoli gruppi diventino troppo influenti. Le nuove tecnologie di staking possono aiutare ad assicurare che i validatori di Ethereum restino il più decentralizzati possibile, difendendoli da guasti hardware, software e di rete. Ciò include software che condividono le responsabilità del validatore tra più nodi. Questo è noto come **tecnologia del validatore distribuita (DVT)**. I gruppi di staking sono incentivati a utilizzare la DVT, poiché consente a più computer di partecipare collettivamente alla validazione, aggiungendo ridondanza e tolleranza ai guasti. Inoltre, divide le chiavi del validatore tra diversi sistemi, piuttosto che far eseguire più validatori ai singoli operatori. Questo complica la coordinazione di attacchi tra operatori disonesti contro Ethereum. Nel complesso, l'idea è quella di ricavare benefici per la sicurezza, eseguendo i validatori come _comunità_ piuttosto che come individui. + +Informazioni sulla tecnologia del validatore distribuita + +L'implementazione della **separazione tra propositore e costruttore (PBS)** migliorerà drasticamente le difese integrate di Ethereum contro la censura. La PBS consente a ogni validatore di creare un blocco e un altro per trasmetterli per la rete di Ethereum. Questo assicura che i guadagni derivati dagli algoritmi di massimizzazione del profitto professionali di costruzione dei blocchi siano condivisi equamente per la rete, **impedendo la concentrazione dello stake** con gli staker istituzionali dalle migliori prestazioni nel tempo. Il propositore di blocchi seleziona il blocco più redditizio offertogli da un mercato di costruttori di blocchi. Per censurare, spesso un propositore di blocchi dovrebbe scegliere un blocco meno redditizio, che sarebbe **economicamente irrazionale e anche ovvio per il resto dei validatori** sulla rete. + +Esistono potenziali componenti aggiuntivi alla PBS, quali transazioni crittografate ed elenchi d'inclusione, che potrebbero ulteriormente migliorare la resistenza alla censura di Ethereum. Questi rendono il costruttore e il propositore di blocchi cieco alle transazioni effettive incluse nei propri blocchi. + +Leggi sulla separazione tra propositore e costruttore + +## Proteggere i validatori {#protecting-validators} + +È possibile che un utente malevolo sofisticato possa identificare i prossimi validatori e spammarli per impedire loro di proporre blocchi; questo è noto come un attacco di **negazione del servizio (o DoS)**. L'implementazione dell'[**elezione segreta di un capo (SLE)**](/roadmap/secret-leader-election), proteggerà da questo tipo di attacchi, impedendo ai propositori di blocchi di essere noti in anticipo. Ciò funziona rimescolando continuamente una serie di impegni crittografici che rappresentano i propositori di blocchi candidati, e utilizzarne l'ordine per determinare quale validatore sia selezionato, in modo che soltanto gli stessi validatori sappiano il proprio ordine in anticipo. + +Leggi sull'elezione segreta di un capo + +## Stato attuale {#current-progress} + +Gli aggiornamenti di sicurezza sulla tabella di marcia sono in fasi di ricerca avanzate, ma non dovrebbero essere implementati per un po'. I prossimi passaggi per view-merge, PBS, SSF e SLE sono quelli di finalizzazione di una specifica e inizio di costruzione dei prototipi. diff --git a/src/content/translations/it/roadmap/single-slot-finality/index.md b/src/content/translations/it/roadmap/single-slot-finality/index.md new file mode 100644 index 00000000000..68c0b4d9cf8 --- /dev/null +++ b/src/content/translations/it/roadmap/single-slot-finality/index.md @@ -0,0 +1,66 @@ +--- +title: Finalità dello spazio singolo +description: Spiegazione della finalità dello spazio singolo +lang: it +--- + +# Finalità dello spazio singolo {#single-slot-finality} + +Perché un blocco di Ethereum sia finalizzato, sono necessari circa 15 minuti. Tuttavia, possiamo far validare i blocchi al meccanismo di consenso di Ethereum, in modo più efficiente, riducendo drasticamente il tempo di finalizzazione. Invece di attendere quindici minuti, i blocchi potrebbero essere proposti e finalizzati nello stesso blocco. Questo concetto è noto come **finalità dello spazio singolo (o SSF)**. + +## Cos'è la finalità? {#what-is-finality} + +Nel meccanismo di consenso basato sul proof-of-stake di Ethereum, la finalità si riferisce alla garanzia che un blocco non sia alterabile o rimovibile dalla blockchain, senza bruciare almeno il 33% degli ETH in staking totali. Questa è la sicurezza 'cripto-economica', poiché la confidenza proviene dai costi estremamente elevati associati al cambiamento dell'ordine o del contenuto della catena, che impedirebbe a qualsiasi attore economico razionale di provarci. + +## Perché mirare a una finalità più rapida? {#why-aim-for-quicker-finality} + +I tempi correnti per la finalità sono diventati troppo lunghi. Gran parte degli utenti non vogliono attendere 15 minuti per la finalità ed è scomodo per app e piattaforme di scambio, che potrebbero volere un volume di transazione elevato per attendere così tanto, per essere certi che le proprie transazioni siano permanenti. Inoltre, avere un ritardo tra la proposta e la finalizzazione di un blocco, crea un'opportunità per delle brevi riorganizzazioni, che un utente malevolo potrebbe utilizzare per censurare certi blocchi, o estrarre il MEV. Il meccanismo che affronta l'aggiornamento dei blocchi in fasi, inoltre, è abbastanza complesso ed è stato corretto diverse volte per chiudere delle vulnerabilità di sicurezza, rendendolo una delle parti della base di codice di Ethereum in cui è più probabile che emergano piccoli bug. Questi problemi potrebbero essere eliminati riducendo il tempo alla finalità in un singolo spazio. + +## Il compromesso tra decentralizzazione, tempo e costi di gestione {#the-decentralization-time-overhead-tradeoff} + +La garanzia di finalità non è una proprietà immediata di un nuovo blocco: ci vuole del tempo affinché un nuovo blocco sia finalizzato. Il motivo è che i validatori che rappresentano almeno i 2/3 degli ETH in staking totali sulla rete, devono votare per il blocco ("attestarlo"), perché sia considerabile come finalizzato. Ogni nodo di convalida sulla rete deve elaborare le attestazioni dagli altri nodi per poter sapere se un blocco ha ottenuto tale soglia di 2/3 o no. + +Più è breve il tempo consentito per raggiungere la finalizzazione, maggiore è la potenza di calcolo necessaria a ogni nodo perché l'elaborazione dell'attestazione sia eseguita più velocemente. Inoltre, più nodi di convalida esistono sulla rete, più attestazioni devono essere elaborate per ogni blocco, da aggiungere alla potenza d'elaborazione necessaria. Più potenza di elaborazione è necessaria, meno persone possono partecipare a causa della necessità di hardware più costoso, per operare ogni nodo di convalida. Aumentare il tempo tra blocchi riduce la potenza di calcolo necessaria a ogni nodo ma allunga il tempo di finalizzazione, poiché le attestazioni sono elaborate più lentamente. + +Dunque, esiste un compromesso tra i costi di gestione (potenza di calcolo), la decentralizzazione (il numero di nodi che possono partecipare alla convalida della catena) e il tempo di finalizzazione. Il sistema ideale equilibra la minima potenza di calcolo, la massima decentralizzazione e il tempo di finalizzazione minimo. + +Il meccanismo di consenso corrente di Ethereum equilibra questi tre parametri: + +- **Impostando lo stake minimo su 32 ETH**. Questo imposta un limite massimo sul numero delle attestazioni dei validatori che devono essere elaborate dai singoli nodi e, dunque, un limite massimo sui requisiti di calcolo per ogni nodo. +- **Impostando il tempo di finalizzazione a circa 15 minuti**. Questo da' abbastanza tempo ai validatori operati su normali computer domestici di elaborare in sicurezza le attestazioni per ogni blocco. + +Con l'attuale design del meccanismo, per poter ridurre il tempo di finalizzazione, è necessario ridurre il numero di validatori sulla rete o aumentare i requisiti hardware per ogni nodo. Tuttavia, esistono dei miglioramenti apportabili all'elaborazione delle attestazioni che possono consentire il conteggio di ulteriori attestazioni senza aumentare i costi di gestione di ogni nodo. L'elaborazione più efficiente consentirà la determinazione della finalità in un singolo spazio, piuttosto che su due epoche. + +## Percorsi allo SSF {#routes-to-ssf} + + + +Il meccanismo di consenso attuale combina le attestazioni da più validatori, noti come commissioni, per ridurre il numero di messaggi che ogni validatore deve elaborare per convalidare un blocco. Ogni validatore ha l'opportunità di attestare in ogni epoca (32 spazi), ma in ogni spazio, soltanto un sottoinsieme di validatori attesta, noto come 'commissione'. Lo fanno dividendosi in reti secondarie, in cui alcuni validatori sono selezionati per essere 'aggregatori'. Questi combinano ognuno tutte le firme che vedono da altri validatori nella propria rete secondaria in una singola firma aggregata. L'aggregatore che include il numero massimo di singoli contributi, ne passa la firma aggregata al propositore di blocchi, che la include nel blocco insieme alla firma aggregata da altre commissioni. + +Questo procedimento fornisce la capacità sufficiente per ogni validatore di votare in ogni epoca, poiché `32 spazi * 64 commissioni * 256 validatori per commissione = 524.288 validatori per epoca`. Al momento della scrittura (febbraio 2023), esistono circa 513.000 validatori attivi. + +In questo schema, è possibile per ogni validatore, votare esclusivamente su un blocco, distribuendo le proprie attestazioni per l'intera epoca. Tuttavia, esistono potenzialmente dei metodi per migliorare il meccanismo, così che _ogni validatore abbia la possibilità di attestare a ogni spazio_. + + +Dalla progettazione del meccanismo di consenso di Ethereum, lo schema di aggregazione delle firme (BLS), è stato ben più scalabile di quanto si pensasse inizialmente, mentre è stata migliorata anche l'abilità dei client di elaborare e verificare le firme. Si è scoperto che le attestazioni di elaborazione da un gran numero di validatori è in realtà possibile, entro un singolo spazio. Ad esempio, con un milione di validatori che votano due volte per ogni spazio e con i tempi dello spazio regolati a 16 secondi, i nodi dovrebbero verificare a un tasso minimo di 125.000 aggregazioni al secondo, per elaborare tutto il milione di attestazioni nello spazio. In realtà, un normale computer richiede circa 500 nanosecondi per eseguire la verifica di una firma, a significare che se ne possono eseguire 125.000 in circa 62,5 ms; molto meno della soglia di un secondo. + +Ulteriori incrementi d'efficienza potrebbero derivare dalla creazione di super-commissioni di, ad esempio, 125.000 validatori selezionati casualmente, per spazio. Solo questi validatori possono votare su un blocco e, dunque, solo questo sottoinsieme di validatori decide se un blocco è finalizzato. La bontà di questa idea dipende dal costo che vorrebbe la community per un attacco di successo su Ethereum. Questo perché, invece di richiedere i 2/3 dell'ether in staking totale, un utente malevolo potrebbe finalizzare un blocco disonesto con i 2/3 degli ether in staking _in quella super-commissione_. Questa è un'area di ricerca ancora attiva, ma sembra plausibile che perché un insieme di validatori sia abbastanza grande da richiedere le super-commissioni, il costo di attaccarne una sarebbe estremamente elevato (es., il costo denominato di ETH dell'attacco sarebbe di `2/3 * 125.000 * 32 = circa 2,6 milioni di ETH`). Il costo dell'attacco è regolabile aumentando le dimensioni dell'insieme di validatori (ad esempio, regolando le dimensioni del validatore, così che il costo dell'attacco sia pari a 1 milione di ether, 4 milioni di ether, 10 milioni di ether, etc.). I [sondaggi preliminari](https://youtu.be/ojBgyFl6-v4?t=755) della community sembrano suggerire che 1-2 milioni di ether siano un costo accettabile dell'attacco, implicando circa da 65.536 a 97.152 validatori per super-commissione. + +Tuttavia, la verifica non è la vera impasse: è l'aggregazione della firma a sfidare realmente i nodi del validatore. Ridimensionare l'aggregazione delle firme richiederebbe probabilmente l'aumento del numero di validatori per ogni rete secondaria, aumentandone il numero, o aggiungendo ulteriori livelli d'aggregazione (cioè, implementando commissioni delle commissioni). Parte della soluzione potrebbe essere consentire degli agreggatori specializzati, similmente a come la costruzione del blocco e la generaazione degli impegni per i dati dei rollup sarà affidata a costruttori di blocchi specializzati, sotto la separazione propositore-costruttore (PBS) e il Danksharding. + +## Qual è il ruolo della regola di scelta della biforcazione nello SSF? {#role-of-the-fork-choice-rule} + +Il meccanismo del consenso odierno si affida a un rigoroso accoppiamento tra il dispositivo di finalità (l'algoritmo che determina se i 2/3 dei validatori hanno attestato a una certa catena) e la regola di scelta della biforcazione (l'algoritmo che decide quale catena è quella corretta, quando ci sono più opzioni). L'algoritmo di scelta della biforcazione considera soltanto i blocchi \_dall'\_ultimo blocco finalizzato. Sotto lo SSF, non ci sarebbe alcun blocco da considerare per la regola di scelta della biforcazione, poiché la finalità si verifica nello stesso spazio in cui è proposto il blocco. Ciò significa che sotto lo SSF, l'algoritmo di scelta \_o\_\_\_ il dispositivo di finalità sarebbero attivi in ogni momento. Il dispositivo di finalità finalizzerebbe i blocchi in cui i 2/3 dei validatori erano online e stavano attestando in modo onesto. Se un blocco non riuscisse a superare la soglia dei 2/3, la regola di scelta della biforcazione entrerebbe in gioco per determinare quale catena seguire. Questo, inoltre, crea un'opportunità per mantenere il meccanismo di perdita dell'inattività che recupera una catena in cui >1/3 dei validatori è offline, sebbene con delle sfumature aggiuntive. + +## Questioni irrisolte {#outstanding-issues} + +Il problema con il ridimensionamento dell'aggregazione, aumentando il numero di validatori per rete secondaria è che comporta un maggiore carico sulla rete tra pari. Il problema con l'aggiunta di livelli di aggregazioni è che è abbastanza complesso progettare e aggiungere latenza (cioè, potrebbe volerci di più per il propositore del blocco di ricevere da tutti gli aggregatori della rete secondaria). Inoltre, non è chiaro come affrontare lo scenario in cui ci siano più validatori attivi sulla rete di quanti fattibilmente ne possano essere elaborati in ogni spazio, anche con l'aggregazione di firme BLS. Una soluzione potenziale è che, poiché tutti i validatori attestano in ogni slot e non esistono commissioni sotto lo SSF, il limite di 32 ETH sul saldo effettivo potrebbe essere interamente rimosso, a significare che gli operatori che gestiscono più validatori potrebbero consolidare i propri ETH in staking ed eseguirne meno, riducendo il numero di messaggi che i nodi di convalida devono elaborare per tenere conto dell'intero insieme di validatori. Ciò si affida sull'accordo da parte dei grandi staker, di consolidare i propri validatori. Inoltre, è possibile imporre un limite fisso sul numero di validatori o sull'importo di ETH in staking, in ogni momento. Tuttavia, ciò richiede dei meccanismi per decidere quali validatori possono partecipare e quali no, responsabili di creare effetti secondari indesiderati. + +## Stato attuale {#current-progress} + +Lo SSF è nella fase di ricerca. Non dovrebbe essere distribuito per svariati anni, possibilmente dopo altri aggiornamenti sostanziali come gli [alberi di Verkle](/roadmap/verkle-trees/) e il [Danksharding](/roadmap/danksharding]). + +## Letture consigliate {#further-reading} + +- [Vitalik sullo SSF all'EDCON 2022](https://www.youtube.com/watch?v=nPgUKNPWXNI) +- [Note di Vitalik: Percorsi alla finalità dello spazio singolo](https://notes.ethereum.org/@vbuterin/single_slot_finality) diff --git a/src/content/translations/it/roadmap/statelessness/index.md b/src/content/translations/it/roadmap/statelessness/index.md new file mode 100644 index 00000000000..bb80535a87e --- /dev/null +++ b/src/content/translations/it/roadmap/statelessness/index.md @@ -0,0 +1,103 @@ +--- +title: Assenza di stato, scadenza di stato e scadenza dello storico +description: Spiegazione della scadenza dello storico e dell'assenza di stato su Ethereum +lang: it +--- + +# Assenza di stato, scadenza di stato e scadenza dello storico {#statelessness} + +L'abilità di operare i nodi di Ethereum su hardware modesti è fondamentale per la vera decentralizzazione. Questo perché operare un nodo da' agli utenti la possibilità di verificare le informazioni, eseguendo controlli crittografici indipendentemente, piuttosto che fidandosi di una terza parte per alimentare i dati. Eseguire un nodo consente agli utenti di inviare le transazioni direttamente alla rete tra pari di Ethereum, piuttosto che doversi fidare di un intermediario. La decentralizzazione non è possibile se tali benefici sono disponibili soltanto per gli utenti con hardware costoso. Invece, i nodi dovrebbero poter operare con requisiti di elaborazione e memoria estremamente modesti, così che possano funzionare su dispositivi mobili, micro-computer o impercettibilmente su un computer di casa. + +Oggi, i requisiti di spazio su disco sono la principale barriera che impedisce l'accesso universale ai nodi. Questo, principalmente, è dovuto al bisogno di memorizzare grandi pezzi dei dati di stato di Ethereum. Questi dati di stato contengono le informazioni critiche necessarie per elaborare correttamente i nuovi blocchi e le nuove transazioni. Al momento della scrittura, è consigliata una SSD veloce da 2TB per eseguire un nodo completo di Ethereum. Per un nodo che non elimina alcun dato vecchio, i requisiti di archiviazione crescono a circa 14GB/settimana e i nodi d'archivio che memorizzano tutti i dati dalla genesi arrivano a circa 12TB (al momento della scrittura, a febbraio 2023). + +Dischi rigidi più economici sono utilizzabili per memorizzare i dati più vecchi, ma sono troppo lenti per tenere il passo con i blocchi in entrata. Mantenere i modelli di archiviazione correnti per i client mentre i dati diventano più economici e facili da archiviare è soltanto temporaneo e, una soluzione parziale al problema, poiché la crescita dello stato di Ethereum è 'senza limiti', a significare che i requisiti d'archiviazione possono soltanto aumentare e, i miglioramenti tecnologici dovranno sempre mantenere il passo con la continua crescita di stato. Invece, i client devono trovare metodi per verificare i blocchi e le transazioni, senza affidarsi alla ricerca dei dati sui database locali. + +## Ridurre l'archiviazione per i nodi {#reducing-storage-for-nodes} + +Esistono vari metodi per ridurre la quantità di dati che ogni nodo deve memorizzare, ognuno richiedente l'aggiornamento del protocollo principale di Ethereum, in misure diverse: + +- **Scadenza dello storico**: consente ai nodi di scartare i dati di stato precedenti a X blocchi, senza modificare la gestione dei dati di stato del client di Ethereum +- **Scadenza di stato**: consente ai dati di staato non utilizzati di frequente di divenire inattivi. I dati inattivi sono ignorabili dai client, finché non sono "resuscitati". +- **Assenza di stato debole**: solo i produttori di blocchi necessitano dell'accesso ai dati di stato completi, altri nodi possono verificare i blocchi senza un database di stato locale. +- **Assenza di stato forte**: nessun nodo necessita dell'accesso ai dati di stato completi. + +## Scadenza dei dati {#data-expiry} + +### Scadenza dello storico {#history-expiry} + +La scadenza dello storico si riferisce ai client, che rimuovono i dati vecchi che è improbabile che necessiteranno, così da memorizzare soltanto una piccola quantità di dati storici, abbandonando i dati precedenti, quando arrivano i nuovi dati. Esistono due motivi per cui i client necessitano dei dati storici: sincronizzazione e servizio delle richieste di dati. Originariamente, i client dovevano sincronizzarsi dal blocco di genesi, verificando che ogni blocco successivo fosse corretto fino alla testa della catena. Oggi, i client utilizzano i "punti di controllo di soggettività deboli" per farsi strada alla testa della catena. Questi punti di controllo sono punti di partenza affidabili, come avere un blocco di genesi vicino al presente, piuttosto che all'inizio di Ethereum. Ciò significa che i client possono rilasciare tutte le informazioni precedenti al punto di controllo di soggettività debole più recente, senza perdere la capacità di sincronizzarsi con la testa della catena. I client, al momento, servono le richieste (in arrivo tramite JSON-RPC) per i dati storici, prendendole dai propri database locali. Tuttavia, con la scadenza dello storico non sarà possibile se i dati richiesti sono stati eliminati. È nel servire questi dati storici che sono necessarie delle soluzioni innovative. + +Un'opzione è che i client richiedano i dati storici dai pari, utilizzando una soluzione come la Portal Network. La Portal Network è una rete tra pari in via di sviluppo per servire i dati storici, in cui ogni nodo memorizza una piccola parte dello storico di Ethereum, così che l'intero storico esista, ma distribuito sulla rete. Le richieste sono servite ricercando i pari che memorizzano i dati rilevanti e richiedendoli. Altrimenti, poiché generalmente sono le app a richiedere l'accesso ai dati storici, può diventare loro responsabilità memorizzarli. Potrebbero anche esistere abbastanza utenti altruisti nello spazio di Ethereum, desiderosi di mantenere gli archivi storici. Potrebbe essere una DAO, eseguita per gestire l'archiviazione dei dati storici o, idealmente, sarebbe una combinazione di tali opzioni. Questi fornitori potrebbero servire i dati in molti modi, come su un torrent, FTP, Filecoin o IPFS. + +La scadenza dello storico è piuttosto controversa perché finora Ethereum ha sempre garantito implicitamente la disponibilità di qualsiasi dato storico. Una sincronizzazione completa dalla genesi è sempre stata possibile come standard, anche se si affida alla ricostruzione di alcuni dati precedenti da delle istantanee. La scadenza dello storico sposta la responsabilità di fornire questa garanzia, all'esterno del protocollo principale di Ethereum. Questo potrebbe introdurre nuovi rischi di censura, se delle organizzazioni centralizzate finissero per intervenire nel fornire i dati storici. + +L'EIP-4444 non è ancora pronto alla distribuzione, ma è in discussione attiva. È interessante notare che, le sfide con l'EIP-4444 non sono molto tecniche, ma prevalentemente relative alla gestione della community. Perché possa essere distribuita, è necessario coinvolgere la community, così che includa non soltanto accordo, ma anche impegni a memorizzare e servire i dati storici, da entità affidabili. + +Questo aggiornamento, fondamentalmente, non modifica come i nodi di Ethereum gestiscono i dati di stato, modifica semplicemente come i dati storici siano accessibili. + +### Scadenza dello stato {#state-expiry} + +La scadenza di stato fa riferimento alla rimozione dello stato dai singoli nodi, se non è stato acceduto di recente. Esistono vari modi per implementarlo, tra cui: + +- **Scadenza per noleggio**: addebitando un "noleggio" ai conti e facendoli scadere quando il noleggio raggiunge lo zero +- **Scadenza per tempo**: rendendo i conti inattivi se non si verifica alcuna lettura/scrittura a quel conto, per un dato periodo di tempo + +La scadenza per noleggio potrebbe essere un noleggio diretto addebitato ai conti per mantenerli nel database dello stato attivo. La scadenza per tempo potrebbe essere un conto alla rovescia dall'ultima interazione del conto, o una scadenza periodica di tutti i conti. Potrebbero inoltre esistere dei meccanismi che combinano gli elementi dei modelli basati su tempo e affitto, ad esempio, i conti individuali persistono nello stato attivo se pagano delle piccole commissioni, prima della scadenza. Con la scadenza di stato è importante notare che lo stato inattivo **non è eliminato**, è soltanto memorizzato separatamente da quello attivo. Lo stato inattivo può essere resuscitato nello stato attivo. + +Questo dovrebbe probabilmente funzionare con un albero di stato per periodi di tempo specifici (forse di circa 1 anno). Ogni volta che inizia un nuovo periodo, inizia un albero di stato completamente nuovo. Solo l'albero di stato corrente è modificabile, tutti gli altri sono immutabili. I nodi di Ethereum devono contenere soltanto l'albero di stato corrente e il successivo più recente. Questo richiede un metodo per mettere in sequenza un indirizzo, con il periodo in cui esiste. Esistono [svariati metodi possibili](https://ethereum-magicians.org/t/types-of-resurrection-metadata-in-state-expiry/6607) per farlo, ma l'opzione principale richiede l'[allungamento degli indirizzi](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485) per accomodare le informazioni aggiuntive, con il beneficio aggiunto che gli indirizzi più lunghi sono più sicuri. Il punto della tabella di marcia che fa questo è detto [estensione dello spazio dell'indirizzo](https://ethereum-magicians.org/t/increasing-address-size-from-20-to-32-bytes/5485). + +Analogamente alla scadenza dello storico, sotto la scadenza di stato, la responsabilità di memorizzare i vecchi dati di stato è rimossa dai singoli utenti e spinta ad altre entità, come fornitori centralizzati, membri altruisti dell community o soluzioni decentralizzate più futuristiche, come la Portal Network. + +La scadenza dello stato è ancora in fase di ricerca e non è ancora pronta alla distribuzione. La scadenza di stato potrebbe verificarsi dopo i client privi di stato e la scadenza dello storico, poiché questi aggiornamenti rendono più facilmente gestibili le grandi dimensioni di stato per gran parte dei validatori. + +## Assenza di stato {#statelessness} + +L'assenza di stato è un termine un po' improprio perché non si riferisce al concetto di eliminazione dello "stato", ma coinvolge delle modifiche alla gestione dei dati di stato dai nodi di Ethereum. L'assenza di stato stessa si presenta in due modalità: debole e forte. L'assenza di stato debole consente a gran parte dei nodi di essere privi di stato, dando la responsabilità dell'archiviazione dello stato a pochi. L'assenza di stato forte rimuove completamente il bisogno, per qualsiasi nodo, di memorizzare i dati di stato completi. Sia l'assenza di stato debole che forte offrono i seguenti benefici ai normali validatori: + +- sincronizzazione quasi istantanea +- abilità di convalidare i blocchi fuori ordine +- nodi capaci di operare con requisiti hardware molto ridotti (es. su telefoni) +- nodi che operano su dischi rigidi economici, perché non è richiesta alcuna lettura/scrittura del disco +- compatibilità con aggiornamenti futuri alla crittografia di Ethereum + +### Assenza di stato debole {#weak-statelessness} + +L'assenza di stato debole richiede modifiche a come i nodi di Ethereum verificano i cambiamenti di stato, ma non elimina completamente il bisogno di archiviare lo stato su tutti i nodi sulla rete. Invece, l'assenza di stato dà la responsabilità d'archiviazione dello stato ai propositori di blocchi, mentre tutti gli altri nodi sulla rete verificano i blocchi senza memorizzare i dati di stato completi. + +**Nell'assenza di stato debole, la proposta dei blocchi richiede l'accesso ai dati di stato completi, ma la verifica dei blocchi no** + +Perché ciò si verifichi, devono già essere stati implementati gli [alberi di Verkle](../verkle-trees) nei client di Ethereum. Gli alberi di Verkle sono strutture di dati sostitutive per memorizzare i dati di stato di Ethereum, che consentono a "testimoni" di dati di dimensioni ridotte e fisse, di essere passati tra i pari e utilizzati per verificare i blocchi, invece di verificarli rispetto ai database locali. Anche la [separazione tra propositori e costruttori](/roadmap/pbs/) è necessaria poiché consente ai costruttori di blocchi di essere nodi specializzati con hardware più potente, essendo coloro che necessitano di accedere ai dati di stato completi. + + + +L'assenza di stato si affida ai costruttori di blocchi che mantengono una copia dei dati di stato completi, così che possano generare testimoni utilizzabili per verificare il blocco. Gli altri nodi non necessitano di accedere ai dati di stato, tutte le informazioni necessarie per verificare il blocco sono disponibili nel testimone. Ciò crea una situazione in cui proporre un blocco è costoso, ma verificarlo è economico, implicando che meno operatori eseguiranno un nodo di proposta dei blocchi. Tuttavia, la decentralizzazione dei propositori di blocchi non è fondamentale, finché quanti più partecipanti possibili possono verificare indipendentemente che i blocchi proposti siano validi. + +Leggi di più sulle note di Dankrad + + +I propositori di blocchi utilizzano i dati di stato per creare dei "testimoni": la serie minima di dati che prova i valori dello stato modificati dalle transazioni in un blocco. Gli altri validatori non detengono lo stato, memorizzano semplicemente la radice di stato (un hash dell'intero stato). Ricevono un blocco e un testimone e li utilizzano per aggiornare la radice di stato. Questo rende un nodo di convalida estremamente leggero. + +L'assenza di stato debole è in uno stato avanzato di ricerca, ma si affida all'implementazione della separazione tra propositori e costruttori e degli Alberi di Verkle, così che i piccoli testimoni possano essere passati tra pari. Ciò significa che l'assenza di stato debole è probabilmente a pochi anni dalla Rete Principale di Ethereum. + +### Assenza di stato forte {#strong-statelessness} + +L'assenza di stato forte rimuove il bisogno di qualsiasi blocco, di memorizzare i dati di stato. Invece, le transazioni sono inviate con i testimoni, aggregabili dai produttori di blocchi. I produttori di blocchi sono quindi responsabili della memorizzazione di soltanto quello stato, necessario per generare testimoni per i conti rilevanti. La responsabilità per lo stato è quasi interamente trasferita agli utenti, poiché inviano i testimoni e 'accedono agli elenchi' per dichiarare con quali conti e quali chiavi d'archiviazione stanno interagendo. + +L'assenza di stato forte è la soluzione più elegante per ridurre i requisiti del disco per i nodi, ma richiede aggiornamenti sostanziali al protocollo di Ethereum. È ancora nella fase di ricerca e non sarà probabilmente distribuita per svariati anni. + +## Stato attuale {#current-progress} + +L'assenza di stato completa è ancora in fase di ricerca ed è probabilmente distante di diversi anni dall'implementazione. L'assenza di stato debole, la scadenza dello storico e la scadenza dello stato sono tutte pietre miliari vero la completa assenza di stato. Anch'esse sono ancora in fase di sviluppo. Non esiste alcuna garanzia che tutte queste proposte saranno implementate, ad esempio, se la scadenza di stato è implementate per prima, non sarebbe necessario implementare anche la scadenza dello storico. Esistono anche altri punti della tabella di marcia, come gli [Alberi di Verkle](/roadmap/verkle-trees) e la [Separazione tra propositori e costruttori](/roadmap/pbs), che necessitano di essere completati per primi. + +## Letture consigliate {#further-reading} + +- [AMA sull'assenza di stato di Vitalik](https://www.reddit.com/r/ethereum/comments/o9s15i/impromptu_technical_ama_on_statelessness_and/) +- [Una teoria sulla gestione delle dimensioni dello stato](https://hackmd.io/@vbuterin/state_size_management) +- [Limitazione dello stato di risurrezione e conflitto minimizzati](https://ethresear.ch/t/resurrection-conflict-minimized-state-bounding-take-2/8739) +- [Percorsi all'assenza di stato e alla scadenza dello stato](https://hackmd.io/@vbuterin/state_expiry_paths) +- [Specifiche dell'EIP-4444](https://eips.ethereum.org/EIPS/eip-4444) +- [Alex Stokes sull'EIP-4444](https://youtu.be/SfDC_qUZaos) +- [Perché l'assenza di stato è così importante](https://dankradfeist.de/ethereum/2021/02/14/why-stateless.html) +- [Le note del concetto originale del client privo di stato](https://ethresear.ch/t/the-stateless-client-concept/172) +- [Informazioni sulla scadenza dello stato](https://hackmd.io/@vbuterin/state_size_management#A-more-moderate-solution-state-expiry) +- [Ulteriori informazioni sulla scadenza di stato](https://hackmd.io/@vbuterin/state_expiry_paths#Option-2-per-epoch-state-expiry) diff --git a/src/content/translations/it/roadmap/user-experience/index.md b/src/content/translations/it/roadmap/user-experience/index.md new file mode 100644 index 00000000000..7ab2722f81d --- /dev/null +++ b/src/content/translations/it/roadmap/user-experience/index.md @@ -0,0 +1,36 @@ +--- +title: Migliorare l'esperienza degli utenti +description: Per molti, è ancora troppo complesso utilizzare Ethereum. Per incoraggiare l'adozione di massa, Ethereum deve ridurre drasticamente le proprie barriere d'accesso; gli utenti devono ricevere i benefici dell'accesso decentralizzato, privo di permessi e resistente alla censura a Ethereum, ma dev'essere privo di frizione, tanto quanto utilizzare una tradizionale app del web2. +lang: it +image: ../../../../../assets/roadmap/roadmap-ux.png +alt: "Roadmap di Ethereum" +template: roadmap +--- + +L'utilizzo di Ethereum dev'essere semplificato; dalla gestione delle chiavi e dei portafogli all'avvio delle transazioni. Per facilitare l'adozione di massa, Ethereum deve aumentare drasticamente la facilità d'uso, consentendo agli utenti di sperimentare un accesso privo di permessi e resistente alla censura a Ethereum, con l'esperienza priva di attrito dell'utilizzo delle app Web2. + +## Oltre le frasi di seed {#no-more-seed-phrases} + +I conti di Ethereum sono protetti da una coppia di chiavi, utilizzate per identificare i conti (chiave pubblica) e firmare i messaggi (chiave privata). Una chiave privata è come una password principale; consente di completare l'accesso a un conto di Ethereum. Questo è un metodo di operazione differente per le persone che hanno più dimestichezza con le banche e le app Web2, che gestiscono i conti per conto di un utente. Perché Ethereum raggiunga l'adozione di massa senza affidarsi a terze parti centralizzate, deve esistere un metodo diretto e privo di attrito per un utente, per prendere custodia delle proprie risorse e mantenere il controllo dei propri dati senza dover comprendere la crittografia delle chiavi pubbliche e private e la gestione delle chiavi. + +La soluzione è utilizzare portafogli di contratti intelligenti per interagire con Ethereum. I portafogli di contratti intelligenti creano modi per proteggere i conti se le chiavi sono perdute o rubate, opportunità per un migliore rilevamento e difesa dalle truffe e consentono ai portafogli di ottenere nuove funzionalità. Sebbene i portafogli di contratti intelligenti esistano oggi, sono imbarazzanti da creare perché il protocollo di Ethereum necessita di supportarli meglio. Questo supporto aggiuntivo è noto come astrazione del conto. + +Di più sull'astrazione del conto + +## Nodi per tutti + +Gli utenti che operano nodi non devono fidarsi di terze parti per fornire loro i dati e possono interagire rapidamente, privatamente e senza permessi con la blockchain di Ethereum. Tuttavia, al momento, operare un nodo richiede una conoscenza tecnica e sostanziale spazio su disco, a significare che molte persone devono invece fidarsi di degli intermediari. + +Esistono diversi aggiornamenti che semplificheranno l'esecuzione dei nodi, riducendo di molto il consumo di risorse. Il metodo di archiviazione dei dati sarà modificato per utilizzare una struttura molto più efficiente a livello di spazio, nota come **Albero di Verkle**. Inoltre, con l'[assenza di stato](/roadmap/statelessness) o la [scadenza dei dati](/roadmap/statelessness/#data-expiry), i nodi di Ethereum non dovranno memorizzare una copia degli interi dati di stato di Ethereum, riducendo drasticamente i requisiti di spazio su disco. I [nodi leggeri](/developers/docs/nodes-and-clients/light-clients/) offriranno molti benefici dell'operare un nodo completo, ma potranno facilmente operare su smartphone o in semplici app per browser. + +Leggi di più sugli alberi di Verkle + +Con questi aggiornamenti, le barriere all'esecuzione di un nodo sono ridotte effettivamente a zero. Gli utenti beneficeranno di un accesso sicuro e privo di permessi a Ethereum, senza dover sacrificare notevole spazio su disco o CPU sul proprio computer o il proprio dispositivo mobile e non dovranno affidarsi a terze parti per l'accesso a dati o alla rete, utilizzando le app. + +## Stato attuale {#current-progress} + +I portafogli di contratti intelligenti sono già disponibili, ma sono necessari maggiori aggiornamenti per renderli il più decentralizzati e privi di permessi possibile. L'EIP-4337 è un proposta matura che non richiede alcuna modifica al protocollo di Ethereum. Il contratto intelligente principale necessario per l'EIP-4337 è stato distribuito a marzo 2023. + +L'assenza di stato completa è ancora in fase di ricerca ed è probabilmente distante di diversi anni dall'implementazione. Esistono diverse pietre miliari sul percorso alla completa assenza di stato, inclusa la scadenza dei dati, che potrebbe essere implementata prima. Devono prima essere completati altri punti della tabella di marcia, come gli [Alberi di Verkle](/roadmap/verkle-trees/) e la [Separazione tra propositori e costruttori](/roadmap/pbs/). + +Le reti di prova degli alberi di Verkle sono già in esecuzione e la prossima fase, consiste nell'operare client che consentano gli alberi di Verkle su reti pubbliche dapprima private, quindi pubbliche. Puoi aiutare ad accelerare il progresso distribuendo contratti alle reti di prova od operando dei client delle reti di prova. diff --git a/src/content/translations/it/roadmap/verkle-trees/index.md b/src/content/translations/it/roadmap/verkle-trees/index.md new file mode 100644 index 00000000000..a62079a30b9 --- /dev/null +++ b/src/content/translations/it/roadmap/verkle-trees/index.md @@ -0,0 +1,65 @@ +--- +title: Alberi di Verkle +description: Una descrizione di alto livello degli alberi di Verkle e di come saranno utilizzati per aggiornare Ethereum +lang: it +summaryPoints: + - Scopri cosa sono gli alberi di Verkle + - Leggi perché gli alberi di Verkle sono un utile aggiornamento per Ethereum +--- + +# Alberi di Verkle {#verkle-trees} + +Gli alberi di Verkle (un neologismo tra "Impegno Vettoriale" e "Alberi di Merkle") sono strutture di dati utilizzabili per aggiornare i nodi di Ethereum, così che possano smettere di archiviare grandi quantità di dati di stato, senza perdere l'abilità di convalidare i blocchi. + +## Assenza di stato {#statelessness} + +Gli alberi di Verkle sono un passaggio fondamentale sul percorso per i client di Ethereum privi di stato. I client privi di stato sono quelli che non devono memorizzare l'intero database di stato per poter convalidare i blocchi in entrata. Invece di utilizzare la propria copia dello stato di Ethereum per verificare i blocchi, utilizzano un "testimone" ai dati di stato che arriva con il blocco. Un testimone è una raccolta di pezzi individuali dei dati di stato, necessaria per eseguire una serie particolare di transazioni, nonché una prova crittografica che il testimone sia davvero parte dei dati completi. Il testimone è utilizzato _invece_ del database di stato. Perché funzioni, i testimoni devono essere molto piccoli, così che siano trasmissibili in sicurezza per la rete, in tempo per essere convalidati dai validatori entro uno spazio di 12 secondi. La struttura attuale dei dati di stato non è adatta, poiché i testimoni sono troppo grandi. Gli alberi di Verkle risolvono questo problema consentendo piccoli testimoni e rimuovendo una delle principali barriere ai client privi di stato. + + + +I client di Ethereum, al momento, utilizzano una struttura di dati nota come Albero di Patricia di Merkle per memorizzarne i dati di stato. Le informazioni sui singoli conti sono memorizzati come foglie su un albero e, le coppie di foglie, ricevono ripetutamente un hash finché non ne resta soltanto uno. Questo hash finale è noto come la "radice". Per verficare i blocchi, i client di Ethereum eseguono tutte le transazioni in un blocco e aggiornano il proprio albero di stato locale. Il blocco è considerato valido se la radice dell'albero locale è identica a quella fornita dal propositore di blocchi, poiché qualsiasi differenza nel calcolo effettuato dal propositore del blocco e dal nodo di convalida, formerebbe un hash di radice completamente differente. Il problema è che la verifica della blockchain richiede che ogni client memorizzi l'intero albero di stato per il blocco di testa e per diversi blocchi storici (di default, su Geth, sono mantenuti i dati di stato per 128 blocchi oltre la testa). Ciò richiede che i client abbiano accesso a una grande quantità di spazio su disco, limitando l'esecuzione dei nodi completi su hardware economici e poco potenti. Una soluzione è aggiornare l'albero di stato a una struttura più efficiente (l'albero di Verkle), riepilogabile utilizzando un piccolo "testimone" ai dati, condivisibile invece dei dati di stato completi. Riformattare i dati di stato in un albero di Verkle è una pietra miliare per spostarsi verso i client privi di stato. + + + +## Cos'è un testimone e perché è necessario? {#what-is-a-witness} + +Verificare un blocco significa rieseguire le transazioni contenute nel blocco, applicando le modifiche all'albero di stato di Ethereum e calcolando il nuovo hash della radice. Un blocco verificato è uno il cui hash della radice di stato calcolato equivale a quello fornito con il blocco (poiché ciò preclude che il propositore del blocco abbia realmente effettuato il calcolo che dice di aver effettuato). Nei client odierni di Ethereum, aggiornare lo stato richiede l'accesso all'intero albero di stato, una grande struttura di dati che dev'essere archiviata localmente. Un testimone contiene soltanto i frammenti dei dati di stato necessari per eseguire le transazioni nel blocco. Un validatore può quindi utilizzare soltanto quei frammenti per verificare che il propositore di blocchi abbia eseguito le transazioni del blocco e aggiornato correttamente lo stato. Tuttavia, ciò significa che il testimone dev'essere trasferito tra i pari sulla rete di Ethereum abbastanza rapidamente da essere ricevuto ed elaborato da ogni nodo, in sicurezza, entro uno spazio di 12 secondi. Se il testimone è troppo grande, per alcuni nodi potrebbe volerci troppo per scaricarlo e tenere il passo con la catena. Questa è una forza centralizzante, poiché significa che soltanto i nodi con connessioni a Internet veloci, possono partecipare alla convalida dei blocchi. Con gli alberi di Verkle non è necessario memorizzare lo stato sul proprio disco rigido; _tutto_ ciò che serve per verificare un blocco, si trova nel blocco stesso. Purtroppo, i testimoni producibili dagli alberi di Merkle sono troppo grandi per supportare i client privi di stato. + +## Perché gli alberi di Verkle consentono testimoni più piccoli? {#why-do-verkle-trees-enable-smaller-witnesses} + +La struttura di un Albero di Merkle rende le dimensioni dei testimoni molto grandi, troppo per trasmetterli in sicurezza tra pari entro uno spazio di 12 secondi. Questo perché il testimone è un percorso che connette i dati, tenuti tra le foglie, all'hash della radice. Per verificare i dati è necessario non soltanto avere tutti gli hash intermedi che connettono ogni foglia alla radice, ma anche tutti i nodi "gemelli". Ogni nodo nella prova ha un gemello, con cui è eseguito l'hash per creare quello successivo. Questi sono molti dati. Gli alberi di Verkle riducono le dimensioni dei testimoni accorciando la distanza tra le foglie dell'albero e la sua radice, nonché eliminando la necessità di provare i nodi gemelli per verificare l'hash della radice. Una maggiore efficienza di spazio sarà ottenuta utilizzando un potente schema di impegno polinomiale, invece dell'impegno vettoriale con hash. L'impegno polinomiale consente al testimone di avere una dimensione fissa indipendentemente dal numero di foglie che prova. + +Sotto lo schema di impegno polinomiale, i testimoni hanno dimensioni gestibili, facilmente trasferibili sulla rete tra pari. Questo consente ai client di verificare i cambiamenti di stato in ogni blocco con una quantità minima di dati. + + + +Le dimensioni dei testimoni variano a seconda del numero di foglie che include. Supponendo che il testimone copra 1000 foglie, un testimone per un albero di Merkle occuperebbe all'incirca 3,5 MB (ipotizzando 7 livelli all'albero). Un testimone per gli stessi dati in un albero di Verkle (ipotizzando 4 livelli all'albero) occuperebbe circa 150 kB; **circa 23 volte più piccolo**. Questa riduzione delle dimensioni del testimone consentirà ai testimoni del client di essere accettabilmente piccoli. I testimoni polinomiali variano da 0,128 a 1 kB a seconda di quale specifico impegno polinomiale è utilizzato. + + + +## Qual è la struttura di un albero di Verkle? {#what-is-the-structure-of-a-verkle-tree} + +Gli alberi di Verkle sono coppie `(key,value)` in cui le chiavi sono elementi da 32 byte composte da uno _stelo_ di 31 byte e un _suffisso_ di un singolo byte. Queste chiavi sono organizzate in nodi _estensione_ e nodi _interni_. I nodi d'estensione rappresentano un singolo stelo per 256 figli con suffissi differenti. Anche i nodi interni hanno 256 figli, ma possono essere altri nodi d'estensione. La differenza principale tra la struttura dell'albero di Verkle e dell'albero di Merkle è che il primo è molto più piatto, a significare che ci sono meno nodi intermedi che collegano una foglia alla radice e dunque sono richiesti meno dati per generare una prova. + +![](./verkle.png) + +[Leggi di più sulla struttura degli alberi di Verkle](https://blog.ethereum.org/2021/12/02/verkle-tree-structure) + +## Stato attuale {#current-progress} + +Le reti di prova dell'albero di Verkle sono già in esecuzione, ma servono ancora aggiornamenti sostanziali e straordinari, necessari a supportarli. Puoi aiutare ad accelerare il progresso distribuendo contratti alle reti di prova od operando dei client delle reti di prova. + +[Esplora la rete di prova di Verkle di Beverly Hills](https://beverlyhills.ethpandaops.io) + +[Guarda Guillaume Ballet spiegare la rete di prova di Verkle di Condrieu](https://www.youtube.com/watch?v=cPLHFBeC0Vg) (nota che la rete di prova di Condrieu era in proof-of-work e, ora, è stata sospesa dalla [rete di prova di Kaustinen](https://kaustinen.ethdevops.io)). + +## Letture consigliate {#further-reading} + +- [Dankrad Feist spiega gli alberi di Verkle su PEEPanEIP](https://www.youtube.com/watch?v=RGJOQHzg3UQ) +- [Guillaume Ballet spiega gli alberi di Verkle all'ETHGlobal](https://www.youtube.com/watch?v=f7bEtX3Z57o) +- ["Come gli alberi di Verkle rendono Ethereum snello e succinto" di Guillaume Ballet al Devcon 6](https://www.youtube.com/watch?v=Q7rStTKwuYs) +- [Piper Merriam sui client privi di stato dall'ETHDenver 2020](https://www.youtube.com/watch?v=0yiZJNciIJ4) +- [Dankrad Fiest spiega gli alberi di Verkle e l'assenza di stato al podcast "Zero Knowledge"](https://zeroknowledge.fm/episode-202-stateless-ethereum-verkle-tries-with-dankrad-feist/) +- [Vitalik Buterin sugli alberi di Verkle](https://vitalik.ca/general/2021/06/18/verkle.html) +- [Dankrad Feist sugli alberi di Verkle](https://dankradfeist.de/ethereum/2021/06/18/verkle-trie-for-eth1.html) +- [Documentazione sull'EIP degli alberi di Verkle](https://notes.ethereum.org/@vbuterin/verkle_tree_eip#Illustration) diff --git a/src/content/translations/it/security/index.md b/src/content/translations/it/security/index.md index 73c1a9f56ca..b154344efa6 100644 --- a/src/content/translations/it/security/index.md +++ b/src/content/translations/it/security/index.md @@ -55,8 +55,8 @@ Ricordare password forti e univoche per ogni tuo conto, non è ideale. Un gestor - [Bitwarden](https://bitwarden.com/) - [KeePass](https://keepass.info/) -- [LastPass](https://www.lastpass.com/) - [1Password](https://1password.com/) +- O date un'occhiata agli altri [gestori di password consigliati](https://www.privacytools.io/secure-password-manager) ### Usa l'autenticazione a due fattori {#two-factor-authentication} @@ -137,7 +137,7 @@ Con lo screenshot delle tue frasi seed o delle chiavi private, rischi di sincron ### Usa un portafoglio hardware {#use-hardware-wallet} -Un portafoglio hardware fornisce spazio offline per le chiavi private. Sono considerati l'opzione di portafoglio più sicura per memorizzare le chiavi private. +Un portafoglio hardware fornisce spazio offline per le chiavi private. Sono considerati l'opzione del portafoglio più sicura per memorizzare le chiavi private: la chiave privata non tocca mai Internet e rimane completamente locale sul tuo dispositivo. Mantenere le chiavi private offline riduce massicciamente il rischio di essere violati, anche se un hacker ottiene il controllo del computer. @@ -158,13 +158,13 @@ Interagendo con i contratti intelligenti, non consentire limiti di spesa illimit Molti portafogli di Ethereum offrono una protezione dei limiti per salvaguardarti dal prosciugamento dei conti. -[Esplora portafogli con protezione dei limiti](/wallets/find-wallet/?filters=has_limits_protection) +[Come revocare l'accesso dei contratti intelligenti ai tuoi fondi di criptovalute](/guides/how-to-revoke-token-access/) ## Truffe comuni {#common-scams} -I truffatori sono sempre alla ricerca di modi per toglierti i fondi. È impossibile fermare completamente i truffatori, ma possiamo renderli meno efficaci essendo consapevoli delle tecniche più utilizzate. Ci sono molte varianti di queste truffe, ma generalmente seguono gli stessi schemi di alto livello. Se non altro, ricorda: +I truffatori sono sempre alla ricerca di modi per sottrarre illecitamente fondi. È impossibile fermare completamente i truffatori, ma possiamo renderli meno efficaci grazie a una maggiore consapevolezza delle tecniche più utilizzate. Esistono molte varianti di queste truffe, ma generalmente seguono gli stessi schemi generali. Se non altro, è bene ricordare: - sii sempre scettico/a - nessuno ti darà ETH gratis o scontati @@ -174,17 +174,17 @@ I truffatori sono sempre alla ricerca di modi per toglierti i fondi. È impossib Una delle truffe più comuni in criptovaluta è la truffa del giveaway. La truffa del giveaway può assumere molte forme, ma la premessa generale è che se invii ETH all'indirizzo del portafoglio fornito, riceverai indietro il tuo ETH ma raddoppiato. *Per questa ragione è conosciuta anche come la truffa del 2 per 1.* -Queste truffe di solito prevedono un periodo limitato di opportunità per richiedere l'omaggio incoraggiando un processo decisionale scadente e creare un falsa senso di urgenza. +Queste truffe di solito prevedono un periodo limitato di opportunità per richiedere l'omaggio incoraggiando un processo decisionale scadente e creare un falso senso di urgenza. #### Hack dei social media {#social-media-hacks} -A luglio 2020 si è verificata una simile versione ad alto profilo, quando i profili di Twitter di celebrità e organizzazioni prominenti, sono stati violati. L'hacker ha pubblicato simultaneamente un giveaway di Bitcoin sui conti violati. Sebbene i tweet ingannevoli siano stati rapidamente notati ed eliminati, gli hacker riuscirono comunque a farla franca con un'estorsione del valore di 11 bitcoin (o $500.000 a settembre 2021). +A luglio 2020 si è verificata una simile versione di alto profilo, quando sono stati violati i profili di Twitter di celebrità e organizzazioni importanti. L'hacker ha pubblicato simultaneamente un giveaway di Bitcoin sui conti violati. Sebbene i tweet ingannevoli siano stati rapidamente notati ed eliminati, gli hacker sono comunque riusciti a farla franca con un'estorsione del valore di 11 bitcoin (o $500.000 a settembre 2021). ![Una truffa su Twitter](./appleTwitterScam.png) #### Dono di celebrità {#celebrity-giveaway} -Il giveaway di celebrità è un altro dei più comuni tipi di truffa del giveaway. I truffatori, utilizzando un'intervista video registrata o una conferenza di una celebrità, la trasmettono in streaming live su YouTube, facendo credere che la celebrità in questione stia promuovendo in diretta un giveaway di criptovalute. +Il giveaway di celebrità è un altro dei più comuni tipi di truffa del giveaway. I truffatori, utilizzando un'intervista video registrata o la conferenza di una celebrità, la trasmettono in streaming live su YouTube, facendo credere che la celebrità in questione stia promuovendo in diretta un giveaway di criptovalute. Vitalik Buterin è la celebrità più sfruttata per questa truffa, ma vengono usate anche molte altre persone importanti coinvolte nelle criptovalute (ad esempio Elon Musk o Charles Hoskinson). L'inclusione di una persona nota dà allo streaming live dei truffatori un senso di legittimità (sembra strano, ma se ne parla Vitalik, dovrebbe essere tutto ok). @@ -194,7 +194,7 @@ Vitalik Buterin è la celebrità più sfruttata per questa truffa, ma vengono us ### Truffe del finto addetto al supporto {#support-scams} -Le criptovalute sono una tecnologia relativamente giovane e incompresa. Una truffa comune che sfrutta tale caratteristica è quella dei finti addetti al supporto: i truffatori fingono di essere addetti al supporto di portafogli, piattaforme di scambio o blockchain popolari. +Le criptovalute sono una tecnologia relativamente giovane e incompresa. Una truffa comune che sfrutta tale caratteristica è quella dei finti operatori del servizio clienti: i truffatori fingono di essere operatori del servizio clienti per portafogli, piattaforme di scambio o blockchain popolari. Gran parte delle discussioni su Ethereum avviene su Discord. I finti addetti al supporto tecnico cercano di solito la propria vittima tra gli utenti che hanno inviato domande al supporto nei canali Discord pubblici e poi inviano a tali utenti un messaggio privato offrendo assistenza. Costruendo la fiducia, i finti addetti al supporto cercano di indurti a rivelare le tue chiavi private o a inviare i tuoi fondi ai loro portafogli. @@ -214,7 +214,7 @@ Come regola generale, il personale non comunicherà mai con te attraverso canali ### Truffa del token "Eth2" {#eth2-token-scam} -Nella corsa a [La Fusione](/roadmap/merge/), i truffatori hanno approfittato della confusione sul termine 'Eth2' per provare a convincere gli utenti a riscattare i propri ETH per un token 'ETH2'. Non esiste alcun 'ETH2' e non è stato introdotto alcun altro token legittimo con La Fusione. Gli ETH che possedevi prima de La Fusione, sono gli stessi ETH adesso. **Non serve intraprendere alcuna azione correlata ai tuoi ETH per tenere conto del passaggio dal proof-of-work al proof-of-stake**. +Nella corsa alla [Fusione](/roadmap/merge/), i truffatori hanno approfittato della confusione sul termine 'Eth2' per provare a convincere gli utenti a riscattare i propri ETH per un token 'ETH2'. Non esiste alcun 'ETH2' e non è stato introdotto alcun altro token legittimo con La Fusione. Gli ETH che possedevi prima de La Fusione, sono gli stessi ETH adesso. **Non serve intraprendere alcuna azione correlata ai tuoi ETH per tenere conto del passaggio dal proof-of-work al proof-of-stake**. I truffatori potrebbero apparire sotto forma di "supporto", dicendoti che se depositi i tuoi ETH, riceverai degli 'ETH2' in cambio. Non esiste alcun [supporto ufficiale di Ethereum](/community/support/) e non esiste alcun nuovo token. Non condividere mai la frase di seed del tuo portafoglio con nessuno. @@ -224,9 +224,9 @@ _Nota: esistono token/ticker derivativi che potrebbero rappresentare ETH in stak Le truffe di phishing sono un altro metodo sempre più comune che i truffatori utilizzeranno, per tentare di rubare i fondi del tuo portafoglio. -Alcune email di phishing chiedono agli utenti di cliccare su link che li reindirizzeranno a siti web falsi, chiedendo loro di inserire la loro frase di seed, ripristinare la loro password o di inviare ETH. Gli altri potrebbero chiederti di installare inconsapevolmente un malware, per infettarti il computer e dare accesso ai file del tuo computer ai truffatori. +Alcune e-mail di phishing chiedono agli utenti di cliccare su link che li reindirizzeranno a siti web falsi, chiedendo loro di inserire la loro frase di seed, ripristinare la loro password o di inviare ETH. Altri potrebbero chiederti di installare inconsapevolmente un malware, per infettarti il computer e dare accesso ai file del tuo computer ai truffatori. -Se ricevi un'email da un mittente sconosciuto, ricorda: +Se ricevi un'e-mail da un mittente sconosciuto, ricorda: - Non aprire mai un link o un allegato da indirizzi e-mail che non riconosci - Non divulgare mai le tue informazioni personali o password a nessuno @@ -240,13 +240,13 @@ Le truffe dei broker di trading di criptovalute affermano di esser broker specia Questi broker fraudolenti trovano le proprie vittime usando profili YouTube falsi per creare conversazioni apparentemente naturali sul broker. Queste conversazioni, spesso, sono molto votate positivamente, per aumentarne la legittimità, sebbene i voti positivi provengano tutti da bot. -**Non fidarti degli sconosciuti su Internet che desiderano investire per tuo conto. Perderai le tue criptovalute.** +**Non fidarti degli sconosciuti su Internet che vogliono investire per tuo conto. Perderai le tue criptovalute.** ![Una truffa del broker di trading su YouTube](./brokerScam.png) ### Truffe dei pool di mining di criptovalute {#mining-pool-scams} -Da settembre 2022, il mining su Ethereum non è più possibile. Tuttavia, le truffe dei pool di mining continuano a esistere. Le truffe dei pool di mining coinvolgono persone che ti contattano senza esser sollecitati e che affermano che tu possa ricevere grandi introiti unendoti a un pool di mining di Ethereum. Il truffatore farà affermazioni e rimarrà in contatto con te per tutto il tempo necessario. Essenzialmente, il truffatore proverà a convincerti che se ti unisci a un pool di mining di Ethereum, la tua criptovaluta sarà usata per creare ETH e che riceverai dei dividendi sotto forma di ETH. Alla fine, noterai che la tua criptovaluta avrà scarsi rendimenti. Ciò, semplicemente, serve per invogliarti a investire di più. Infine, tutti i tuoi fondi saranno inviati a un indirizzo sconosciuto e il truffatore scomparirà o, in alcuni casi, continuerà a rimanere in contatto, come successo in un caso recente. +Da settembre 2022, il mining su Ethereum non è più possibile. Tuttavia, le truffe dei pool di mining continuano a esistere. Le truffe dei pool di mining coinvolgono persone che ti contattano di propria iniziativa e che affermano che potrai ricevere grandi introiti unendoti a un pool di mining di Ethereum. Il truffatore farà affermazioni e rimarrà in contatto con te per tutto il tempo necessario. Essenzialmente, il truffatore proverà a convincerti che se ti unisci a un pool di mining di Ethereum, la tua criptovaluta sarà usata per creare ETH e che riceverai dei dividendi sotto forma di ETH. Alla fine, noterai che la tua criptovaluta avrà scarsi rendimenti. Questo serve solo a invogliarti a investire di più. Infine, tutti i tuoi fondi saranno inviati a un indirizzo sconosciuto e il truffatore scomparirà o, in alcuni casi, continuerà a rimanere in contatto, come successo in un caso recente. In conclusione, diffida delle persone che ti contattano sui social, chiedendoti di far parte di un pool di mining. Una volta perse le tue criptovalute, non potrai fare nulla. @@ -260,7 +260,7 @@ Alcune cose da ricordare: ### Truffe airdrop {#airdrop-scams} -Le truffe di Airdrop prevedono un falso progetto di airdropping di una risorsa (NFT, token) nel tuo portafoglio e ti inviano a un sito web di truffa per rivendicare la risorsa in questione. Ti sarà richiesto di accedere con il tuo portafoglio di Ethereum e di "approvare" una transazione tentando di reclamare. Questa transazione compromette il tuo conto inviando la tua chiave pubblica e privata al truffatore. Una forma alternativa di questa truffa potrebbe chiederti di confermare una transazione che invia fondi al conto del truffatore. +Le truffe di Airdrop prevedono un falso progetto di airdropping di una risorsa (NFT, token) nel tuo portafoglio e ti inviano a un sito web di truffa per rivendicare la risorsa in questione. Ti sarà chiesto di accedere con il tuo portafoglio di Ethereum e di "approvare" una transazione tentando di reclamare. Questa transazione compromette il tuo conto inviando la tua chiave pubblica e privata al truffatore. Una forma alternativa di questa truffa potrebbe chiederti di confermare una transazione che invia fondi al conto del truffatore. [Maggiori informazioni sulle truffe di airdrop](https://www.youtube.com/watch?v=LLL_nQp1lGk) @@ -287,3 +287,5 @@ Le truffe di Airdrop prevedono un falso progetto di airdropping di una risorsa ( - [Staying Safe: Common Scams](https://support.mycrypto.com/staying-safe/common-scams) - _MyCrypto_ - [Evitare le Truffe](https://bitcoin.org/en/scams) - _Bitcoin.org_ - [Discussione di Twitter sulle email e i messaggi di phishing di criptovalute comuni](https://twitter.com/tayvano_/status/1516225457640787969) - _Taylor Monahan_ + + diff --git a/src/content/translations/it/staking/pools/index.md b/src/content/translations/it/staking/pools/index.md index 13427eaf88e..54bc7bbcc4a 100644 --- a/src/content/translations/it/staking/pools/index.md +++ b/src/content/translations/it/staking/pools/index.md @@ -17,7 +17,7 @@ summaryPoints: I pool di staking sono un approccio collaborativo per consentire a molti, con quantità minori di ETH, di ottenere i 32 ETH necessari per attivare un insieme di chiavi di validazione. La funzionalità di pooling non è supportata nativamente all'interno del protocollo, quindi le soluzioni sono state sviluppate separatamente per rispondere a questa esigenza. -Alcuni pool operano utilizzando i contratti intelligenti, dove i fondi possono essere depositati in un contratto, che gestisce e traccia in modo affidabile il tuo stake, e ti emette un token che rappresenta questo valore. Altri pool potrebbero non coinvolgere i contratti intelligenti ed essere invece mediati al di fuori dalla catena. +Alcuni pool operano utilizzando i contratti intelligenti, dove i fondi possono essere depositati in un contratto, che gestisce e traccia senza fiducia il tuo stake, e ti emette un token che rappresenta questo valore. Altri pool potrebbero non coinvolgere i contratti intelligenti ed essere invece mediati al di fuori dalla catena. ## Perché mettere in stake con un pool? {#why-stake-with-a-pool} @@ -64,11 +64,7 @@ Tipicamente, i token di liquidità ERC-20 sono emessi agli staker che rappresent -Al momento, è impossibile prelevare fondi da un validatore di Ethereum, il che limita l'abilità di riscattare effettivamente il tuo token di liquidità per le ricompense in ETH bloccate nel livello del consenso. - -L'aggiornamento della rete Shanghai introdurrà la funzionalità di prelievo, pianificata per il primo o secondo trimestre del 2023. Tutti gli ETH in staking resteranno bloccati fino ad allora. - -Dopo questo aggiornamento, i conti dei validatori che sostengono i pool di staking avranno la possibilità di uscire e prelevare ETH al proprio indirizzo designato di prelievo. Ciò consentirà di riscattare la porzione di stake per gli ETH sottostanti. Confrontati con il tuo fornitore per scoprire come supporta tale funzionalità. +Subito! L'aggiornamento della rete di Shanghai/Capella è avvenuto ad aprile 2023 e ha introdotto i prelievi di staking. I conti del validatore che sostengono i pool di staking hanno ora la possibilità di uscire e prelevare ETH al proprio indirizzo di prelievo designato. Ciò consente di riscattare la propria parte di stake per gli ETH sottostanti. Confrontati con il tuo fornitore per scoprire come supporta tale funzionalità. Altrimenti, i pool che usano un token di liquidità ERC-20 consentono agli utenti di scambiarlo nel mercato aperto, consentendoti di vendere la tua posizione di staking, "prelevando" effettivamente senza rimuovere realmente ETH dal contratto di staking. diff --git a/src/content/translations/it/staking/saas/index.md b/src/content/translations/it/staking/saas/index.md index fe382d081ef..5d1cef0d760 100644 --- a/src/content/translations/it/staking/saas/index.md +++ b/src/content/translations/it/staking/saas/index.md @@ -58,7 +58,7 @@ Hai un suggerimento per un fornitore di staking come servizio che abbiamo diment ## Domande frequenti {#faq} - Le disposizioni differiranno da fornitore a fornitore, ma in genere, sarai guidato alla configurazione di qualsiasi chiave di firma necessaria (una per 32 ETH) e al loro caricamento al tuo fornitore per consentirgli di validare per conto tuo. Le sole chiavi di firma non danno alcuna possibilità di prelevare, trasferire o spendere i tuoi fondi. Tuttavia, forniscono la possibilità di trasmettere voti a favore di un consenso, il che, se non fatto propriamente, può risultare in sanzioni offline o tagli. +Le disposizioni differiranno da fornitore a fornitore, ma in genere, sarai guidato alla configurazione di qualsiasi chiave di firma necessaria (una per 32 ETH) e al loro caricamento al tuo fornitore per consentirgli di validare per conto tuo. Le sole chiavi di firma non danno alcuna possibilità di prelevare, trasferire o spendere i tuoi fondi. Tuttavia, forniscono la possibilità di trasmettere voti a favore di un consenso, il che, se non fatto propriamente, può risultare in sanzioni offline o tagli. @@ -66,25 +66,25 @@ Sì. Ogni conto si compone sia di chiavi di firma che di chiavi di Le chiavi di prelievo BLS sono utilizzate per firmare un messaggio una tantum che dichiara a chi dovrebbero andare le ricompense di staking del conto del livello d'esecuzione e i fondi prelevati. Una volta trasmesso questo messaggio, le chiavi di prelievo BLS non saranno più necessarie. Invece, il controllo dei fondi prelevati è permanentemente delegato all'indirizzo fornito. Ciò consente di impostare un indirizzo di prelievo protetto tramite l'archiviazione a freddo, minimizzando il rischio per i tuoi fondi del validatore, anche se qualcun altro controlla le chiavi di firma del tuo validatore. -Aggiornare le credenziali di prelievo è un passaggio necessario per abilitare i prelievi con l'aggiornamento Shanghai. Questo processo comporta la generazione delle chiavi di prelievo, utilizzando la tua frase di seed mnemonica. Assicurati di eseguire il backup di questa frase di seed in sicurezza o non potrai generare le tue chiavi di prelievo quando arriverà il momento. +Aggiornare le credenziali di prelievo è un passaggio necessario per consentire i prelievi\*. Questo processo comporta la generazione delle chiavi di prelievo, utilizzando la tua frase di seed mnemonica. -Gli staker che lo hanno già fornito con il deposito iniziale, non dovranno impostare un indirizzo di prelievo. Confrontati con il tuo fornitore SaaS per ricevere assistenza con la preparazione del validatore. +Accertati di eseguire in sicurezza il backup di questa frase di seed, o non potrai generare le tue chiavi di prelievo quando arriverà il momento. + +\*Gli staker che hanno fornito un indirizzo di prelievo con il deposito iniziale non hanno necessità di impostarle. Confrontati con il tuo fornitore SaaS per ricevere assistenza con la preparazione del validatore. -Quando metti 32 ETH in stake con un fornitore di SaaS, quegli ETH sono ancora depositati al contratto di deposito di staking ufficiale. Come tali, gli staker di SaaS sono limitati dalle stesse limitazioni di prelievo degli staker in solo e i prelievi non saranno abilitati fino all'aggiornamento Shanghai. - -I prelievi di staking saranno implementati nel prossimo aggiornamento Shanghai, previsto tra il primo e il secondo trimestre del 2023. Dopodiché, gli staker dovranno fornire un indirizzo di prelievo (se non è fornito sul deposito iniziale) e i pagamenti delle ricompense inizieranno a essere distribuiti automaticamente su base periodica ogni pochi giorni. +I prelievi di staking sono stati implementati nell'aggiornamento di Shanghai/Capella, ad aprile 2023. Gli staker devono fornire un indirizzo di prelievo (se non è stato fornito al deposito iniziale) e i pagamenti delle ricompense inizieranno a essere distribuiti automaticamente su base periodica, a intervalli di pochi giorni. -Ciò consentirà anche di sbloccare i fondi usciti. I validatori possono uscire completamente da tale ruolo e riceveranno il loro saldo per intero all'indirizzo di prelievo fornito. +I validatori, inoltre, possono uscire interamente come tali, il che sbloccherà il loro saldo in ETH rimanente per il prelievo. I conti che hanno fornito un indirizzo di prelievo d'esecuzione e hanno completato il procedimento di uscita riceveranno interamente il proprio saldo all'indirizzo di prelievo fornito durante la successiva pulizia dei validatori. Di più sulle ricompense di staking -Usando un fornitore di Saas, affidi l'operazione del tuo nodo a qualcun altro. Questo comporta il rischio delle scarse prestazioni del nodo, che non dipendono da te. Nell'evento in cui il tuo validatore sia tagliato, il saldo del tuo validatore sarà sanzionato e forzatamente rimosso dal pool dei validatori. Questi fondi saranno bloccati finché i prelievi non saranno abilitati a livello del protocollo. +Usando un fornitore di Saas, affidi l'operazione del tuo nodo a qualcun altro. Questo comporta il rischio delle scarse prestazioni del nodo, che non dipendono da te. Nell'evento in cui il tuo validatore sia tagliato, il saldo del tuo validatore sarà sanzionato e forzatamente rimosso dal pool dei validatori. -L'imminente aggiornamento Shanghai introduce la funzionalità di prelievo, che ai fini dell'attivazione richiede di fornire un indirizzo di prelievo. Questo potrebbe essere stato fornito al deposito iniziale. Altrimenti, le chiavi di firma del validatore dovranno essere utilizzate per firmare un messaggio che dichiari un indirizzo di prelievo, al momento dell'aggiornamento. +Fino al completamento del procedimento di taglio/uscita, questi fondi saranno trasferiti all'indirizzo di prelievo assegnato al validatore. Ciò richiede di fornire un indirizzo di prelievo, per poter essere abilitato. Questo potrebbe essere stato fornito al deposito iniziale. Altrimenti, le chiavi di prelievo del validatore dovranno essere usate per firmare un messaggio che dichiari un indirizzo di prelievo. Se non è stato fornito alcun indirizzo di prelievo, i fondi resteranno bloccati finché non sarà fornito. Contatta il singolo fornitore di SaaS per ulteriori dettagli su qualsiasi opzione di garanzia o assicurazione e per le istruzioni su come fornire un indirizzo di prelievo. Se preferisci avere il pieno controllo della configurazione del tuo validatore, scopri di più su come fare staking in solo dei tuoi ETH. diff --git a/src/content/translations/it/staking/solo/index.md b/src/content/translations/it/staking/solo/index.md index 92c506f9e5f..2faf14a36c2 100644 --- a/src/content/translations/it/staking/solo/index.md +++ b/src/content/translations/it/staking/solo/index.md @@ -40,32 +40,37 @@ Lo staking in solo richiede una maggiore responsabilità, ma fornisce il massimo Per quanto vorremmo che lo staking in solo fosse accessibile e privo di rischi per tutti, questa non è la realtà. Esistono alcune serie considerazioni pratiche da tenere a mente prima di scegliere di mettere i tuoi ETH in staking in solo. - - Quando utilizzi il tuo nodo, dovresti dedicare del tempo a imparare come usare il software che hai scelto. Questo include la lettura della documentazione pertinente e seguire i canali di comunicazione di tali team di sviluppo. - Più comprendi il software che stai operando e il funzionamento del proof-of-stake, meno rischioso sarà come staker e più sarà facile risolvere qualsiasi problema che potrebbe sorgere lungo il percorso da operatore del nodo. - - - La configurazione del nodo richiede un livello di dimestichezza ragionevole con il computer, sebbene nuovi strumenti stiano semplificando le procedure con il tempo. La comprensione dell'interfaccia della riga di comando è utile, ma non più rigorosamente richiesta. - Richiede anche una configurazione hardware molto basilare e una minima comprensione delle specifiche consigliate minime. - - - Proprio come le chiavi private proteggono il tuo indirizzo di Ethereum, dovrai generare chiavi specificamente per il tuo validatore. Devi comprendere come mantenere al sicuro qualsiasi frase di seed o chiave privata. -

Sicurezza di Ethereum e prevenzione delle truffe

- - - Il prelievo degli ETH in staking o delle ricompense dal saldo di un validatore non è ancora supportato. Il supporto per i prelievi è pianificato per il prossimo aggiornamento Shanghai. Dopodiché, gli utenti potranno aderire per ricevere automaticamente i pagamenti delle ricompense e potranno prelevare il saldo per intero per ricevere i fondi. - - - L'hardware, talvolta, si guasta, le connessioni di rete generano errori e il software del client a volte necessita di aggiornamenti. La manutenzione del nodo è inevitabile e richiederà occasionalmente la tua attenzione. Vorrai assicurarti di esser consapevole di qualsiasi aggiornamento di rete anticipato o di altri aggiornamenti critici del client. - - - Le tue ricompense sono proporzionali al tempo in cui il tuo validatore è online e sta attestando propriamente. Le interruzioni comportano sanzioni proporzionali a quanti altri validatori sono offline nello stesso momento, ma non risultano in tagli. Anche la larghezza di banda conta, poiché le ricompense sono ridotte per le attestazioni che non sono ricevute in tempo. I requisiti varieranno, ma si consiglia un minimo di 10 Mb/s in upload e download. - - - Differente dalle sanzioni di inattività per esser offline, il taglio è una sanzione molto più seria, riservata alle infrazioni malevole. Operando un client di minoranza con le tue chiavi caricate su una sola macchina per volta, il tuo rischio di esser tagliato è minimizzato. Detto ciò, tutti gli staker devono esser consapevoli dei rischi di taglio. - -

Ulteriori informazioni sul taglio e il ciclo di vita del validatore

- + +Quando utilizzi il tuo nodo, dovresti dedicare del tempo a imparare come usare il software che hai scelto. Questo include la lettura della documentazione pertinente e seguire i canali di comunicazione di tali team di sviluppo. + +Più comprendi il software che stai operando e il funzionamento del proof-of-stake, meno rischioso sarà come staker e più sarà facile risolvere qualsiasi problema che potrebbe sorgere lungo il percorso da operatore del nodo. + + + +La configurazione del nodo richiede un livello di dimestichezza ragionevole con il computer, sebbene nuovi strumenti stiano semplificando le procedure con il tempo. La comprensione dell'interfaccia della riga di comando è utile, ma non più rigorosamente richiesta. + +Richiede anche una configurazione hardware molto basilare e una minima comprensione delle specifiche consigliate minime. + + + +Proprio come le chiavi private proteggono il tuo indirizzo di Ethereum, dovrai generare delle chiavi specificamente per il tuo validatore. Devi comprendere come mantenere al sicuro qualsiasi frase di seed o chiave privata. + +Sicurezza di Ethereum e prevenzione delle truffe + + + +L'hardware, talvolta, si guasta, le connessioni di rete generano errori e il software del client a volte necessita di aggiornamenti. La manutenzione del nodo è inevitabile e richiederà occasionalmente la tua attenzione. Vorrai assicurarti di esser consapevole di qualsiasi aggiornamento di rete anticipato o di altri aggiornamenti critici del client. + + + +Le tue ricompense sono proporzionali al tempo in cui il tuo validatore è online e sta attestando propriamente. Le interruzioni comportano sanzioni proporzionali a quanti altri validatori sono offline nello stesso momento, ma non risultano in tagli. Anche la larghezza di banda conta, poiché le ricompense sono ridotte per le attestazioni che non sono ricevute in tempo. I requisiti varieranno, ma si consiglia un minimo di 10 Mb/s in upload e download. + + + +Differente dalle sanzioni di inattività per esser offline, il taglio è una sanzione molto più seria, riservata alle infrazioni malevole. Operando un client di minoranza con le tue chiavi caricate su una sola macchina per volta, il tuo rischio di esser tagliato è minimizzato. Detto ciò, tutti gli staker devono esser consapevoli dei rischi di taglio. + +Maggiori informazioni su tagli e il ciclo di vita del validatore + @@ -78,8 +83,6 @@ Quando saranno attivi, riceverai le ricompense in ETH, che saranno depositate pe Se lo desideri, puoi smettere di essere un validatore; in questo modo viene meno il requisito di essere online e si interrompe qualsiasi ulteriore ricompensa. Il saldo rimanente sarà poi prelevato all'indirizzo di prelievo che hai indicato durante la configurazione. -_L'aggiornamento Shanghai è necessario per consentire i pagamenti delle ricompense e i prelievi completi dei validatori in uscita._ - [Di più sulle ricompense di staking](/staking/withdrawals/) ## Inizia con il Launchpad di Staking {#get-started-on-the-staking-launchpad} @@ -126,14 +129,14 @@ Esistono alcune domande molto comuni sullo staking che meritano di essere affron -Un _validatore_ è un'entità virtuale che risiede su Ethereum e partecipa al consenso del protocollo di Ethereum. I validatori sono rappresentati da un saldo, una chiave pubblica e altre proprietà. Un _client del validatore_ è il software che agisce per conto del validatore, detenendone e usandone la chiave privata. Un singolo client del validatore può detenere molte coppie di chiavi, controllando molti validatori. +Un validatore è un'entità virtuale che risiede su Ethereum e partecipa al consenso del protocollo di Ethereum. I validatori sono rappresentati da un saldo, una chiave pubblica e altre proprietà. Un client del validatore è il software che agisce per conto del validatore detenendone e usandone la chiave privata. Un singolo client del validatore può detenere molte coppie di chiavi, controllando molti validatori. Ogni coppia di chiavi associata ad un validatore richiede esattamente 32 ETH per esser attivata. Maggiori ETH depositati in una singola serie di chiavi non aumentano le potenziali ricompense, poiché ogni validatore è limitato a un saldo effettivo di 32 ETH. Questo significa che lo staking è effettuato in incrementi di 32 ETH, ognuno con la propria serie di chiavi e il proprio saldo. -Non depositare più di 32 ETH per un singolo validatore. Non aumenterà le tue ricompense e sarà bloccato fino all'aggiornamento Shanghai pianificato. +Non depositare più di 32 ETH per un singolo validatore. Non incrementerà le tue ricompense. Se un indirizzo di prelievo è stato impostato per il validatore, i fondi in eccesso oltre i 32 ETH saranno prelevati automaticamente a tale indirizzo durante la successiva pulizia dei validatori. Se lo staking in solo sembra troppo impegnativo per te, considera di usare un fornitore di staking come servizio, o se stai operando con meno di 32 ETH, dai un'occhiata ai pool di staking. @@ -155,8 +158,10 @@ Operare un client di super maggioranza (ogni client usato da oltre 2/3 della ret I bug equivalenti in un client di minoranza non sarebbero mai finalizzati e, ciò risulterebbe in un voto di contorno, con la semplice conseguenza di sanzioni d'inattività, non tagli. -

Scopri di più sull'importanza di eseguire un client di minoranza.

-

Scopri di più sulla prevenzione dei tagli

+ @@ -173,14 +178,12 @@ Sebbene un server privato virtuale (VPS) possa essere usato come sostitutivo del Più client del validatore operano su una soluzione d'archiviazione su cloud centralizzata singola, più diventa pericoloso per questi utenti. Ogni evento che porta questi fornitori offline, che sia un attacco, domande regolatorie o solo guasti energetici o a Internet, manderanno offline al contempo ogni client del validatore che si basi su tale server. Le sanzioni offline sono proporzionali a quanti altri sono offline contemporaneamente. Usare un VPS aumenta notevolmente il rischio che le sanzioni offline saranno più severe e aumenta il rischio di fughe quadratiche o tagli nel caso in cui il guasto sia abbastanza grande. Per minimizzare i tuoi rischi e i rischi alla rete, gli utenti sono vivamente incoraggiati a procurarsi e utilizzare il proprio hardware. - -Ulteriori informazioni su ricompense e sanzioni -Al momento dell'aggiornamento Shanghai, saranno disponibili i pagamenti delle ricompense e i prelievi completi per i validatori in uscita. I prelievi di ogni tipo dalla beacon chain richiedono l'impostazione delle credenziali di prelievo. +I prelievi di ogni tipo dalla beacon chain richiedono l'impostazione delle credenziali di prelievo. -I nuovi staker le hanno impostate al momento della generazione della chiave e del deposito. Gli staker esistenti che non le hanno già impostate, potranno aggiornare le proprie chiavi per supportare tale funzionalità, dopo l'aggiornamento Shanghai. +I nuovi staker le hanno impostate al momento della generazione della chiave e del deposito. Gli staker esistenti che non lo hanno già impostato, possono aggiornare le proprie chiavi per supportare questa funzionalità. Una volta impostate le credenziali di prelievo, i pagamenti delle ricompense (gli ETH accumulati oltre i 32 iniziali) saranno distribuiti periodicamente e automaticamente all'indirizzo di prelievo. @@ -197,4 +200,3 @@ Per sbloccare e ricevere il tuo intero saldo, devi inoltre completare il process - [How to: acquistare l'hardware del validatore di Ethereum](https://www.youtube.com/watch?v=C2wwu1IlhDc) - _EthStaker 2022_ - [Passo dopo Passo: come unirsi alla Testnet di Ethereum 2.0](https://kb.beaconcha.in/guides/tutorial-eth2-multiclient) - _Butta_ - [Suggerimenti per la prevenzione dei tagli di Eth2](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50) - _Raul Jordan 2020_ -- [Ricompense e sanzioni su Ethereum 2.0](https://consensys.net/blog/codefi/rewards-and-penalties-on-ethereum-20-phase-0/) - _James BeckMarch 2020_ diff --git a/src/content/translations/it/staking/withdrawals/index.md b/src/content/translations/it/staking/withdrawals/index.md new file mode 100644 index 00000000000..acfe47b3807 --- /dev/null +++ b/src/content/translations/it/staking/withdrawals/index.md @@ -0,0 +1,218 @@ +--- +title: Prelievi di staking +description: Pagina di riepilogo su cosa sono i prelievi push di staking, come funzionano e cosa devono fare gli staker per ottenere le proprie ricompense +lang: it +template: staking +image: ../../../../../assets/staking/leslie-withdrawal.png +alt: Leslie il rinoceronte con le sue ricompense di staking +sidebarDepth: 2 +summaryPoints: + - L'aggiornamento di Shanghai/Capella ha reso possibili i prelievi di staking su Ethereum + - Gli operatori del validatore devono fornire un indirizzo di prelievo per consentirli + - Le ricompense sono distribuite automaticamente a intervalli di pochi giorni + - I validatori che escono interamente dallo staking riceveranno il saldo rimanente +--- + + +I prelievi di staking sono stati resi possibili con l'aggiornamento di Shanghai/Capella, verificatosi il 12 aprile 2023. Ulteriori informazioni su Shanghai/Capella + + +I **prelievi di staking** si riferiscono ai trasferimenti di ETH dal conto di un validatore sul livello di consenso di Ethereum (la Beacon Chain) al livello d'esecuzione in cui possono essere spostati. + +I **pagamenti di ricompense dei saldi in eccesso** rispetto ai 32 ETH saranno inviati automaticamente e regolarmente a un indirizzo di prelievo collegato a ogni validatore, una volta fornito dall'utente. Gli utenti, inoltre, possono **uscire interamente dallo staking**, sbloccando il proprio intero saldo del validatore. + +## Ricompense di staking {#staking-rewards} + +I pagamenti delle ricompense sono elaborati automaticamente per i conti dei validatori attivi con un saldo effettivo massimizzato di 32 ETH. + +Qualsiasi saldo superiore a 32 ETH guadagnato tramite le ricompense non contribuisce effettivamente al capitale, né aumenta il peso di tale validatore sulla rete, pertanto è prelevato automaticamente come pagamento di una ricompensa a intervalli di pochi giorni. A parte fornire un indirizzo di prelievo una tantum, queste ricompense non richiedono alcuna azione da parte dell'operatore del validatore. Tutto questo è avviato sul livello di consenso, dunque non è necessario alcun carburante (commissione di transazione) in nessun passaggio. + +### Come siamo arrivati qui? {#how-did-we-get-here} + +Negli ultimi anni, Ethereum ha subito diversi aggiornamenti della rete, passando a una rete protetta dagli stessi ETH invece che dall'elevato consumo derivato dal mining, com'era in passato. La partecipazione al consenso su Ethereum è nota come "staking", poiché i partecipanti bloccano volontariamente gli ETH, mettendoli "a disposizione" ("at stake", in inglese) per poter partecipare alla rete. Gli utenti che seguono le regole saranno ricompensati, mentre i tentativi di barare saranno penalizzati. + +Dal lancio del contratto di deposito di staking a novembre 2020, alcuni coraggiosi pionieri di Ethereum hanno volontariamente bloccato i propri fondi per attivare i "validatori", conti speciali aventi il diritto di attestare formalmente e proporre blocchi, seguendo le regole della rete. + +Prima dell'aggiornamento di Shanghai/Capella, non era possibile utilizzare i propri ETH in staking o accedervi. Ma ora, puoi optare per ricevere automaticamente le tue ricompense in un determinato conto e, inoltre, puoi prelevare i tuoi ETH in staking quando preferisci. + +### Come mi preparo? {#how-do-i-prepare} + + + +### Avvisi importanti {#important-notices} + +Fornire un indirizzo di prelievo è un passaggio necessario per qualsiasi conto del validatore affinché sia idoneo per il prelievo di ETH dal suo saldo. + + + A ogni conto del validatore è assegnabile solo un unico indirizzo di prelievo, una volta. Una volta che un indirizzo è scelto e inviato alla Beacon Chain, questo non può essere cancellato o modificato. Ricontrolla la proprietà e l'accuratezza dell'indirizzo fornito prima di inviarlo. + + +Nel mentre, non esiste alcuna minaccia ai tuoi fondi per non averlo fornito, supponendo che la tua frase mnemonica/di seed sia rimasta al sicuro offline e non sia stata compromessa in alcun modo. La mancata aggiunta delle credenziali di prelievo lascerà semplicemente gli ETH bloccati nel conto del validatore finché non sarà fornito un indirizzo di prelievo. + +## Uscire interamente dallo staking {#exiting-staking-entirely} + +Fornire un indirizzo di prelievo è necessario prima che _qualsiasi_ fondo possa esser trasferito all'esterno del saldo di un conto del validatore. + +Gli utenti che desiderano uscire interamente dallo staking, prelevando il proprio intero saldo, devono inoltre firmare e trasmettere un messaggio di "uscita volontaria" con le chiavi del validatore, avviando così il procedimento di uscita dallo staking. Ciò avviene con il tuo client validatore e inviandolo al tuo nodo beacon, e non richiede carburante. + +Il processo di uscita di un validatore dallo staking richiede periodi di tempo variabili, a seconda di quanti altri stanno uscendo contemporaneamente. Una volta completato, questo conto non sarà più responsabile dell'esecuzione dei doveri della rete dei validatori e non sarà più idoneo per ricevere ricompense, né avrà i propri ETH "in staking". A questo punto, il conto sarà contrassegnato come interamente "prelevabile". + +Una volta che un conto è contrassegnato come "prelevabile", e le credenziali sono state fornite, un utente non deve fare altro che aspettare. I conti sono ripuliti automaticamente e continuamente dai propositori di blocchi per verificare la presenza di fondi in uscita idonei e il saldo del tuo conto sarà trasferito interamente (anche noto come "prelievo completo") durante la successiva pulizia. + +## Quando saranno abilitati i prelievi di staking? {#when} + +I prelievi di staking sono già operativi! La funzionalità di prelievo è stata abilitata come parte dell'aggiornamento di Shanghai/Capella, verificatosi il 12 aprile 2023. + +L'aggiornamento di Shanghai/Capella ha consentito di rivendicare gli ETH precedentemente messi in staking, in conti regolari di Ethereum. Ciò ha chiuso il ciclo della liquidità di staking e ha portato Ethereum un passo più avanti nel suo percorso per la costruzione di un ecosistema decentralizzato sostenibile, scalabile e sicuro. + +- [Maggiori informazioni sulla storia di Ethereum](/history/) +- [Maggiori informazioni sulla tabella di marcia di Ethereum](/roadmap/) + +## Come funzionano i pagamenti dei prelievi? {#how-do-withdrawals-work} + +Che un dato validatore sia o meno idoneo per un prelievo è determinato dallo stato del conto del validatore stesso. Nessun input dell'utente, in alcun dato momento, è necessario per determinare se un conto dovrebbe avviare o meno un prelievo; l'intero processo è effettuato automaticamente dal livello di consenso in un ciclo continuo. + +### Preferisci un approccio visivo all'apprendimento? {#visual-learner} + +Dai un'occhiata a questa spiegazione dei prelievi di staking di Ethereum, di Finematics: + + + +### "Pulizia" dei validatori {#validator-sweeping} + +Quando è pianificato che un validatore proponga il prossimo blocco, è necessario costruire una coda di prelievo, composta da un massimo di 16 prelievi idonei. Ciò avviene iniziando originariamente dall'indice 0 del validatore, determinando se esista un prelievo idoneo per questo conto secondo le regole del protocollo e, in tal caso, aggiungendolo alla coda. Il validatore impostato per proporre il blocco successivo riprenderà da dove si è fermato il precedente, procedendo indefinitamente in ordine. + + +Pensa a un orologio analogico. La lancetta dell'orologio indica l'ora, progredisce in una direzione, non salta nessuna ora e, infine, torna nuovamente all'inizio dopo aver raggiunto l'ultimo numero.

+Ora invece che da 1 a 12, immagina che l'orologio vada da 0 a N(il numero totale di conti del validatore mai registrati sulla Beacon Chain, oltre 500.000 a gennaio 2023).

+La lancetta dell'orologio punta al validatore successivo che deve essere controllato in cerca di prelievi idonei. Inizia a 0 e procede controllando tutti i conti, senza saltarne nessuno. Quando viene raggiunto l'ultimo validatore, il ciclo continua ricominciando dall'inizio. + + +#### Verificare un conto per i prelievi {#checking-an-account-for-withdrawals} + +Mentre un propositore controlla i validatori per i possibili prelievi, ogni validatore verificato è valutato rispetto a una breve serie di domande per determinare se dovrebbe essere innescato un prelievo e, in tal caso, quanti ETH dovrebbero essere prelevati. + +1. **È stato fornito un indirizzo di prelievo?** Se non è stato fornito alcun indirizzo di prelievo, il conto viene saltato e non viene avviato alcun prelievo. +2. **Il validatore è uscito ed è idoneo al prelievo?** Se il validatore è uscito interamente e abbiamo ricevuto l'epoca in cui tale conto è considerato come "prelevabile", sarà elaborato un prelievo completo. Questo, trasferirà l'intero saldo rimanente all'indirizzo di prelievo. +3. **Il saldo effettivo è massimizzato a 32?** Se il conto ha le credenziali di prelievo, non è interamente uscito e ha ricompense superiori a 32 in attesa, sarà elaborato un prelievo parziale, che trasferirà esclusivamente le ricompense superiori a 32 all'indirizzo di prelievo dell'utente. + +Esistono solo due azioni intraprese dagli operatori del validatore durante il ciclo di vita di un validatore che influenzano direttamente tale flusso: + +- Fornire le credenziali di prelievo per consentire qualsiasi forma di prelievo +- Uscire dalla rete, innescando un prelievo completo + +### Zero carburante {#gas-free} + +Questo approccio ai prelievi di staking evita di richiedere agli staker di inviare manualmente una transazione richiedendo un importo particolare di ETH da prelevare. Ciò significa che **non è necessario alcun carburante (commissione di transazione)** e che il prelievo non compete per lo spazio del blocco del livello d'esecuzione esistente. + +### Con quale frequenza riceverò le mie ricompense di staking? {#how-soon} + +In un unico blocco può essere elaborato un massimo di 16 prelievi. A tale frequenza, possono essere elaborati 115.200 validatori al giorno (supponendo che non vi sia alcuno slot mancante). Come indicato in precedenza, i validatori privi di prelievi idonei saranno saltati, riducendo il tempo necessario per terminare la pulizia. + +Espandendo tale calcolo, possiamo stimare il tempo necessario a elaborare un dato numero di prelievi: + + + +| Numero di prelievi | Tempo di completamento | +| :----------------: | :--------------------: | +| 400.000 | 3,5 giorni | +| 500.000 | 4,3 giorni | +| 600.000 | 5,2 giorni | +| 700.000 | 6,1 giorni | +| 800.000 | 7,0 giorni | + + + +Come vedi, la frequenza rallenta con l'aumento dei validatori sulla rete. Un aumento degli slot mancanti potrebbe rallentarla proporzionalmente, ma questo rappresenta generalmente il lato più lento dei possibili risultati. + +## Domande frequenti {#faq} + + +No, il processo per fornire le credenziali di prelievo è una tantum e queste non sono modificabili una volta inviate. + + + +Impostando un indirizzo di prelievo del livello d'esecuzione, le credenziali di prelievo per quel validatore sono state cambiate permanentemente. Ciò significa che le vecchie credenziali non funzioneranno più e che le nuove credenziali dirigono a un conto del livello d'esecuzione. + +Gli indirizzi di prelievo possono essere un contratto intelligente (controllato dal suo codice) o un conto posseduto esternamente (EOA, controllato dalla sua chiave privata). Attualmente questi conti non hanno alcun modo di comunicare un messaggio al livello di consenso che segnali una modifica delle credenziali del validatore, e aggiungere questa funzionalità aggiungerebbe una complessità non necessaria al protocollo. + +Come alternativa alla modifica dell'indirizzo di prelievo per un dato validatore, gli utenti potrebbero scegliere di impostare un contratto intelligente come proprio indirizzo di prelievo che potrebbe gestirebbe la rotazione delle chiavi, come Safe. Gli utenti che impostano i propri fondi al proprio EOA possono eseguire un'uscita completa per prelevare tutti i propri fondi in staking, per poi rimetterli in staking utilizzando nuove credenziali. + + + + +Se fai parte di un pool di staking o detieni derivati di staking liquidi, dovresti consultare il tuo fornitore per ottenere ulteriori dettagli sulla gestione dei prelievi di staking, poiché ogni servizio opera in modo diverso. + +In generale, gli utenti dovrebbero essere liberi di rivendicare i propri ETH in staking sottostanti, o di modificare il fornitore di staking che utilizzano. Se un pool in particolare sta diventando troppo grande, è possibile uscire, riscattare i fondi e rimetterli in staking con un fornitore di dimensioni minori. O, se hai accumulato abbastanza ETH, potresti fare staking da casa. + + + + +Sì, a condizione che il tuo validatore abbia fornito un indirizzo di prelievo. Questo deve essere fornito una volta per abilitare inizialmente qualsiasi prelievo, poi i pagamenti delle ricompense saranno innescati automaticamente a intervalli di pochi giorni, a ogni pulizia del validatore. + + + + +No, se il tuo validatore è ancora attivo sulla rete, un prelievo completo non si verificherà automaticamente. Questo richiede l'avvio manuale di un'uscita volontaria. + +Una volta che un validatore ha completato il procedimento di uscita e supponendo che il conto abbia le credenziali di prelievo, il saldo rimanente sarà then prelevato durante la successivapulizia del validatore. + + + + +I prelievi sono progettati per avvenire automaticamente, trasferendo qualsiasi ETH che non sta contribuendo attivamente allo staking. Ciò include i saldi completi dei conti che hanno completato il procedimento di uscita. + +Non è possibile richiedere manualmente importi specifici di ETH da prelevare. + + + + +Gli operatori del validatore dovrebbero visitare la pagina dei Prelievi del Launchpad di Staking, dove troveranno ulteriori dettagli su come preparare il proprio validatore ai prelievi. preparato, tempistica degli eventi e ulteriori dettagli sul funzionamento dei prelievi. + +Per testare la tua configurazione su una rete di prova, visita prima il Launchpad di Staking della Rete di Prova di Goerli per iniziare. + + + + +No. Una volta che un validatore è uscito e che il suo intero saldo è stato prelevato, qualsiasi fondo aggiuntivo depositato a quel validatore sarà automaticamente trasferito all'indirizzo di prelievo durante la pulizia successiva del validatore. Per rimettere gli ETH in staking, deve essere abilitato un nuovo validatore. + + +## Letture consigliate {#further-reading} + +- [Prelievi del Launchpad di Staking](https://launchpad.ethereum.org/withdrawals) +- [EIP-4895: La Beacon Chain spinge i prelievi come operazioni](https://eips.ethereum.org/EIPS/eip-4895) +- [Ethereum Cat Herders - Shanghai](https://www.ethereumcatherders.com/shanghai_upgrade/index.html) +- [PEEPanEIP #94: Prelievo di ETH in staking (testing) con Potuz e Hsiao-Wei Wang](https://www.youtube.com/watch?v=G8UstwmGtyE) +- [PEEPanEIP#68: EIP-4895: Prelievi push della Beacon Chain come operazioni con Alex Stokes](https://www.youtube.com/watch?v=CcL9RJBljUs) +- [Informazioni sul saldo effettivo del validatore](https://www.attestant.io/posts/understanding-validator-effective-balance/) diff --git a/src/content/translations/it/web3/index.md b/src/content/translations/it/web3/index.md index 37c75d0d07b..1966ea0698d 100644 --- a/src/content/translations/it/web3/index.md +++ b/src/content/translations/it/web3/index.md @@ -117,7 +117,7 @@ Nonostante i numerosi benefici di Web3 nella sua forma corrente, esistono ancora ### Accessibilità {#accessibility} -Importanti funzionalità di Web3, come Accedi con Ethereum, sono già disponibili per esser usati da chiunque, a costo zero. Ma, il costo relativo delle transazioni è ancora proibitivo per molti. A causa delle commissioni di transazione elevate, è meno probabile che Web3 sia usato nei paesi meno sviluppati e in via di sviluppo. Su Ethereum, queste difficoltà sono risolte tramite gli [aggiornamenti della rete](/roadmap/) e le [soluzioni di ridimensionamento del livello 2](/developers/docs/scaling/). La tecnologia è pronta, ma necessitiamo di una maggiore adozione del livello 2 per rendere Web3 accessibile a tutti. +Importanti funzionalità di Web3, come Accedi con Ethereum, sono già disponibili per esser usati da chiunque, a costo zero. Ma, il costo relativo delle transazioni è ancora proibitivo per molti. A causa delle commissioni di transazione elevate, è meno probabile che Web3 sia usato nei paesi meno sviluppati e in via di sviluppo. Su Ethereum, queste sfide saranno risolte tramite [la tabella di marcia](/roadmap/) e le [soluzioni di ridimensionamento del livello 2](/developers/docs/scaling/). La tecnologia è pronta, ma necessitiamo di una maggiore adozione del livello 2 per rendere Web3 accessibile a tutti. ### Esperienza utente {#user-experience} @@ -157,3 +157,5 @@ Il Web3 non ha una definizione rigida. Vari partecipanti della community hanno p - [Perché la Decentralizzazione È Importante](https://onezero.medium.com/why-decentralization-matters-5e3f79f7638e) - _Chris Dixon_ - [Il Panorama di Web3](https://a16z.com/wp-content/uploads/2021/10/The-web3-Readlng-List.pdf) – _a16z_ - [Il Dibattito su Web3](https://www.notboring.co/p/the-web3-debate?s=r) – _Packy McCormick_ + + diff --git a/src/content/translations/it/web3/web1.png b/src/content/translations/it/web3/web1.png new file mode 100644 index 00000000000..6ebc4bd002c Binary files /dev/null and b/src/content/translations/it/web3/web1.png differ diff --git a/src/content/translations/it/web3/web2.png b/src/content/translations/it/web3/web2.png new file mode 100644 index 00000000000..b966f41f95f Binary files /dev/null and b/src/content/translations/it/web3/web2.png differ diff --git a/src/content/translations/it/web3/web3.png b/src/content/translations/it/web3/web3.png new file mode 100644 index 00000000000..449938c10e9 Binary files /dev/null and b/src/content/translations/it/web3/web3.png differ diff --git a/src/content/translations/it/zero-knowledge-proofs/index.md b/src/content/translations/it/zero-knowledge-proofs/index.md new file mode 100644 index 00000000000..8fa77f10092 --- /dev/null +++ b/src/content/translations/it/zero-knowledge-proofs/index.md @@ -0,0 +1,212 @@ +--- +title: Prove a conoscenza zero +description: Un introduzione "non tecnica" per i principianti sulle prove a conoscenza zero. +lang: it +--- + +## Cosa sono le prove a conoscenza zero? {#what-are-zk-proofs} + +Una prova a conoscenza zero è un modo per provare la validità di una dichiarazione senza rivelarla. Il 'dimostratore' è la parte che tenta di provare una rivendicazione, mentre il 'validatore' è responsabile della sua convalida. + +Le prove a conoscenza zero sono apparse per la prima volta in un documento del 1985, "[La complessità di conoscenza dei sistemi di prova interattiva](http://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Proof%20Systems/The_Knowledge_Complexity_Of_Interactive_Proof_Systems.pdf)", che fornisce una definizione delle prove a conoscenza zero, ampiamente utilizzata oggi: + +> Un protocollo a conoscenza zero è un metodo per cui una parte (il dimostratore), può provare a un'altra parte (il verificatore) che qualcosa sia vero, senza rivelare alcuna informazione, tranne il fatto che tale specifica istruzione sia vera. + +Le prove a conoscenza zero sono migliorate negli anni e adesso sono utilizzate in diverse applicazioni del mondo reale. + +## Perché necessitiamo delle prove a conoscenza zero? {#why-zero-knowledge-proofs-are-important} + +Le prove a conoscenza zero hanno rappresentato una svolta nella crittografia applicata, poiché hanno promesso di migliorare la sicurezza delle informazioni per gli individui. Considera come potresti dimostrare una rivendicazione (es. "Sono un cittadino del paese X") a un'altra parte (es., un fornitore di servizio). Dovresti fornire una "prova" per sostenere la tua rivendicazione, come un passaporto internazionale o la patente di guida. + +Ma questo approccio presenta dei problemi, principalmente la mancanza di privacy. Le informazioni di identificazione personale (PII) condivise con servizi di terze parti sono memorizzate in banche dati centrali, vulnerabili alle violazioni. Poiché il furto d'identità sta diventando un problema critico, è necessario identificare mezzi più efficaci di condivisione delle informazioni sensibili a protezione della privacy. + +Le prove a conoscenza zero risolvono questo problema eliminando la necessità di rivelare informazioni per provare la validità delle rivendicazioni. Il protocollo a conoscenza zero utilizza l'istruzione (detta 'testimone'), come input, per generare una prova succinta della sua validità. Tale prova fornisce forti garanzie che un'istruzione sia vera, senza esporre le informazioni utilizzate per crearla. + +Tornando al nostro esempio precedente, l'unica prova che serve per dimostrare la tua richiesta di cittadinanza è una prova a conoscenza zero. Il verificatore deve soltanto verificare se determinate proprietà della prova sono vere, per essere convinto che anche l'istruzione sottostante sia vera. + +## Come funzionano le prove a conoscenza zero? {#how-do-zero-knowledge-proofs-work} + +Una prova a conoscenza zero permette di dimostrare la verità di una dichiarazione senza condividere i contenuti dell’affermazione o rivelare come l'hai scoperta. A tal fine, i protocolli a conoscenza zero si basano su algoritmi che prendono alcuni dati in entrata e restituiscono ‘true’ o ‘false’ come risultato. + +Un protocollo a conoscenza zero deve soddisfare i seguenti criteri: + +1. **Completezza**: se l'immissione è valida, il protocollo a conoscenza zero restituisce sempre 'true'. Quindi, se la dichiarazione sottostante è vera, se il dimostratore e il validatore agiscono onestamente, la prova può essere accettata. + +2. **Solidità**: se l'immissione non è valida, è teoricamente impossibile ingannare il protocollo a conoscenza zero per restituire 'true'. Quindi, un dimostratore bugiardo non può ingannare un validatore onesto a credere che una dichiarazione non valida sia valida (se non con un piccolo margine di probabilità). + +3. **Conoscenza zero**: il validatore non impara nulla su una dichiarazione se non la sua validità o falsità (hanno “conoscenza zero” della dichiarazione). Questo requisito impedisce anche al validatore di ricavare l'immissione iniziale (il contenuto della dichiarazione) dal protocollo. + +Nella forma semplice, una prova a conoscenza zero è composta da tre elementi: **testimonianza**, **sfida** e **risposta**. + +- **Testimonianza**: Con una prova a conoscenza zero, il dimostratore vuole manifestare la conoscenza di alcune informazioni nascoste. L'informazione segreta è il "testimone" della prova, e la presunta conoscenza del testimone da parte del dimostratore stabilisce una serie di domande a cui può rispondere solo una parte a conoscenza dell'informazione. Pertanto, il dimostratore avvia il processo di prova scegliendo casualmente una domanda, calcolando la risposta e inviandola al verificatore. + +- **Sfida**: il validatore sceglie casualmente un'altra domanda dal set e chiede al dimostratore di rispondere. + +- **Risposta**: Ii dimostratore accetta la domanda, calcola la risposta e la restituisce al validatore. La risposta del dimostratore consente al validatore di verificare se il primo ha realmente accesso al testimone. Per garantire che il dimostratore non indovini alla cieca e ottenga le risposte corrette per caso, il validatore sceglie più domande da porre. Ripetendo questa interazione molte volte, la possibilità che il dimostratore falsifichi la conoscenza del testimone diminuisce in modo significativo fino a quando il validatore non è soddisfatto. + +Quanto sopra descrive la struttura di una “prova interattiva a conoscenze zero”. I primi protocolli a conoscenza zero utilizzavano la dimostrazione interattiva, in cui la verifica della validità di una dichiarazione richiedeva una comunicazione avanti e indietro tra dimostratori e validatori. + +Un buon esempio che illustra come funzionano le prove interattive è la famosa storia di Jean-Jacques Quisquater sulla[ grotta di Ali Baba](https://en.wikipedia.org/wiki/Zero-knowledge_proof#The_Ali_Baba_cave). Nella storia, Peggy (il dimostratore) vuole dimostrare a Victor (il validatore) che conosce la frase segreta per aprire una porta magica senza rivelare la frase. + +### Prove a conoscenze zero non interattive {#non-interactive-zero-knowledge-proofs} + +Sebbene rivoluzionario, la prova interattiva aveva un'utilità limitata poiché richiedeva che le due parti fossero disponibili e interagissero ripetutamente. Anche se un validatore fosse convinto dell’onestà di un dimostratore, la prova non sarebbe disponibile per una verifica indipendente (il calcolo di una nuova prova richiede una nuova serie di messaggi tra il dimostratore e il validatore). + +Per risolvere questo problema, Manuel Blum, Paul Feldman, e Silvio Micali hanno suggerito le prime prove [a conoscenza zero non interattive](https://dl.acm.org/doi/10.1145/62212.62222) in cui il dimostratore e il validatore hanno una chiave condivisa. Ciò permette al dimostratore di manifestare la propria conoscenza di alcune informazioni (ad esempio, testimone) senza fornire le informazioni stesse. + +A differenza delle prove interattive, le prove non interattive richiedevano solo una serie di comunicazioni tra i partecipanti (dimostratore e validatore). Il dimostratore passa le informazioni segrete a un apposito algoritmo per calcolare una prova a conoscenza zero. Questa prova viene inviata al validatore, che controlla che il dimostratore conosca le informazioni segrete utilizzando un altro algoritmo. + +La prova non interattiva riduce la comunicazione tra dimostratore e validatore, rendendo le prove ZK più efficienti. Inoltre, una volta generata una prova, è disponibile per chiunque altro (con accesso alla chiave condivisa e all'algoritmo di verifica) per la verifica. + +Le prove non interattive hanno rappresentato una svolta per la tecnologia a conoscenza zero e hanno stimolato lo sviluppo dei sistemi di dimostrazione utilizzati oggi. Discutiamo questi tipi di prova di seguito: + +### Tipologie di prove a conoscenza zero {#types-of-zero-knowledge-proofs} + +#### ZK-SNARK {#zk-snarks} + +ZK-SNARK è un acronimo per **Zero-Knowledge Succinct Non-Interactive Argoment of Knowledge**. Il protocollo ZK-SNARK ha le seguenti qualità: + +- **Conoscenza zero**: un validatore può convalidare l'integrità di una dichiarazione senza sapere nient'altro sull'affermazione. L'unica conoscenza che il validatore ha della dichiarazione è se è vera o falsa. + +- **Concisione**: la prova a conoscenza zero è più piccola del testimone e può essere verificata rapidamente. + +- **Non interattiva**: la prova è 'non interattiva' perché il dimostratore e il validatore interagiscono solo una volta, a differenza delle prove interattive che richiedono più cicli di comunicazione. + +- **Argomento**: la prova soddisfa il requisito di 'solidità', quindi l'imbroglio è estremamente improbabile. + +- **(Di) Conoscenza**: la prova a conoscenza zero non può essere costruita senza l'accesso a informazioni segrete (testimone). È difficile, se non impossibile, per un dimostratore che non ha il testimone calcolare una valida prova a conoscenza zero. + +La «chiave condivisa» menzionata in precedenza si riferisce a parametri pubblici che il dimostratore e il validatore accettano di utilizzare per generare e verificare le prove. Generare i parametri pubblici (collettivamente noti come la Stringa di Riferimento Comune (CRS)) è un'operazione sensibile data la sua importanza nella sicurezza del protocollo. Se l'entropia (casualità) utilizzata per generare il CRS entra nelle mani di un dimostratore disonesto, possono calcolare delle prove false. + +[Calcolo multipartitico (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) è un modo per ridurre i rischi nella generazione di parametri pubblici. Più parti partecipano a una [ cerimonia di configurazione basata sulla fiducia](https://zkproof.org/2021/06/30/setup-ceremonies/amp/), dove ogni persona contribuisce con alcuni valori casuali per generare il CRS. Finché una parte onesta distrugge la propria porzione di entropia, il protocollo ZK-SNARK mantiene la solidità computazionale. + +Le configurazioni sulla fiducia richiedono agli utenti di fidarsi dei partecipanti alla generazione dei parametri. Tuttavia, lo sviluppo di ZK-STARK ha creato le condizioni affinché i protocolli di prova funzionino con una configurazione non affidabile. + +#### ZK-STARK {#zk-starks} + +ZK-SNARK è un acronimo per **Zero-Knowledge Succinct Non-Interactive Argoment of Knowledge**. I ZK-STARK sono simili ai ZK-SNARK, tranne per il fatto che sono: + +- **Scalabili**: ZK-STARK è più veloce di ZK-SNARK nel generare e verificare prove quando la dimensione del testimone è più grande. Con le prove STARK, i tempi di dimostrazione e verifica aumentano solo leggermente man mano che il testimone cresce (i tempi di dimostrazione e validazione SNARK aumentano linearmente con la dimensione del testimone). + +- **Trasparente**: ZK-STARK si basa sulla casualità verificabile pubblicamente per generare parametri pubblici per la prova e la verifica invece di una configurazione sulla fiducia. Pertanto, sono più trasparenti rispetto agli ZK-SNARK. + +Gli ZK-STARK producono prove più grandi rispetto agli ZK-SNARK, il che significa che generalmente hanno spese generali di verifica più elevate. Tuttavia, esistono casi (come la dimostrazione di grandi set di dati) in cui ZK-STARK può essere più conveniente rispetto a ZK-SNARK. + +## Casi d'uso di prove a conoscenza zero {#use-cases-for-zero-knowledge-proofs} + +### Pagamenti anonimi {#anonymous-payments} + +I pagamenti con carta di credito sono spesso visibili a più parti, inclusi il fornitore dei pagamenti, le banche e altre parti interessate (ad es. autorità governative). La sorveglianza finanziaria comporta vantaggi per l'identificazione delle attività illegali, ma compromette anche la privacy dei cittadini comuni. + +Le criptovalute avevano lo scopo di fornire agli utenti un mezzo per condurre transazioni private e peer-to-peer. Ma la maggior parte delle transazioni di criptovalute è visibile a tutti sulle blockchain pubbliche. Le identità degli utenti sono spesso pseudonime e collegate intenzionalmente a identità del mondo reale (ad esempio includendo indirizzi ETH su profili Twitter o GitHub) o possono essere associate a identità del mondo reale utilizzando l'analisi base, on e off-chain di dati. + +Esistono delle “monete per la privacy” specifiche pensate per transazioni completamente anonime. Le blockchain incentrate sulla privacy, come Zcash e Monero, proteggono i dettagli delle transazioni, inclusi gli indirizzi del mittente/destinatario, il tipo di risorsa, la quantità e la sequenza temporale della transazione. + +Integrando la tecnologia a conoscenza zero nel protocollo, le reti blockchain incentrate sulla privacy consentono ai nodi di convalidare le transazioni senza la necessità di accedere ai dati delle transazioni. + +Le prove a conoscenza zero vengono applicate anche alle transazioni per renderle anonime sulle blockchain pubbliche. Un esempio è Tornado Cash, un servizio decentralizzato e non custodito che consente agli utenti di effettuare transazioni private su Ethereum. Tornado Cash utilizza dimostrazioni a conoscenza zero per offuscare i dettagli delle transazioni e garantire la privacy finanziaria. Purtroppo, visto che questi sono strumenti di privacy "opt-in" sono associati ad attività illecite. Per superare questo problema, la privacy deve diventare l'impostazione predefinita sulle blockchain pubbliche. + +### Protezione dell'identità {#identity-protection} + +Gli attuali sistemi di gestione dell'identità mettono a rischio i dati personali. Le prove a conoscenza zero possono aiutare gli individui a convalidare l'identità proteggendo le informazioni sensibili. + +Le dimostrazioni a conoscenza zero sono particolarmente utili nel contesto di [identità decentralizzata](/decentralized-identity/). L'identità decentralizzata (descritta anche come «identità auto-sovrana») conferisce all'individuo la possibilità di controllare l'accesso agli identificatori personali. Dimostrare la propria cittadinanza senza rivelare il proprio ID fiscale o i dettagli del passaporto è un buon esempio di come la tecnologia a conoscenza zero consente l'identità decentralizzata. + +### Autenticazione {#authentication} + +L'utilizzo di servizi online richiede la prova della tua identità e del diritto di accedere a tali piattaforme. Questo richiede spesso di fornire informazioni personali, come nomi, indirizzi e-mail, date di nascita, e così via. Potrebbe anche essere necessario memorizzare password lunghe o rischiare di perdere l'accesso. + +Le dimostrazioni a conoscenza zero possono, tuttavia, semplificare l'autenticazione sia per le piattaforme che per gli utenti. Una volta che una dimostrazione a conoscenza zero è stata generata utilizzando input pubblici (es., dati che attestano l'appartenenza dell'utente alla piattaforma) e input privati (es., i dati dell'utente), l'utente può semplicemente presentarlo per autenticare la propria identità quando hanno bisogno di accedere al servizio. Questo migliora l'esperienza per gli utenti e libera le organizzazioni dalla necessità di memorizzare enormi quantità di informazioni per gli utenti. + +### Calcolo verificabile {#verifiable-computation} + +Il calcolo verificabile è un'altra applicazione della tecnologia a conoscenza zero per migliorare i progetti blockchain. Il calcolo verificabile ci permette di esternalizzare il calcolo ad un'altra entità mantenendo i risultati verificabili. L'entità presenta il risultato insieme a un'attestazione che verifica che il programma è stato eseguito correttamente. + +Il calcolo verificabile è fondamentale per migliorare la velocità di elaborazione sulle blockchain senza ridurre la sicurezza. Comprendere questo aspetto richiede di conoscere le differenze nelle soluzioni proposte per la scalabilità di Ethereum. + +[Soluzioni scalabili on-chain](/developers/docs/scaling/#on-chain-scaling), come la frammentazione, richiedono ampie modifiche del livello base della blockchain. Tuttavia, questo approccio è molto complesso e gli errori nell'attuazione possono compromettere il modello di sicurezza di Ethereum. + +[Le soluzioni di scaling off-chain](/developers/docs/scaling/#off-chain-scaling) non richiedono una nuova progettazione del protocollo Ethereum di base. Invece si basano su un modello di calcolo esternalizzato per migliorare la produttività sul livello base di Ethereum. + +Ecco come funziona nella pratica: + +- Invece di elaborare ogni transazione, Ethereum scarica l'esecuzione in una catena separata. + +- Dopo aver elaborato le transazioni, l'altra catena restituisce i risultati da applicare allo stato di Ethereum. + +Il vantaggio è che Ethereum non deve fare alcuna esecuzione e deve solo applicare i risultati dal calcolo esternalizzato al suo stato. Ciò riduce la congestione della rete e migliora anche la velocità delle transazioni (i protocolli off-chain vengono ottimizzati per un'esecuzione più rapida). + +La catena ha bisogno di un modo per convalidare le transazioni off-chain senza eseguirle nuovamente, altrimenti il valore dell'esecuzione off-chain viene perso. + +È qui che entra in gioco il calcolo verificabile. Quando un nodo esegue una transazione al di fuori di Ethereum, invia una prova a conoscenza zero per dimostrare la correttezza dell'esecuzione off-chain. Questa prova (chiamata [prova di validità](/glossary/#validity-proof)) garantisce che una transazione è valida, consentendo a Ethereum di applicare il risultato al suo stato, senza attendere che qualcuno contesti. + +I [rollup a conoscenza zero](/developers/docs/scaling/zk-rollups) e [validium](/developers/docs/scaling/validium/) sono due soluzioni di scaling off-chain che utilizzano prove di validità per fornire una scalabilità sicura. Questi protocolli eseguono centinaia di transazioni off-chain e inviano la prova di verifica su Ethereum. Questi risultati possono essere applicati immediatamente dopo che la prova è stata verificata, permettendo ad Ethereum di elaborare più transazioni senza incrementare i calcoli sul livello di base. + +### Ridurre la corruzione e la collusione nelle votazioni on-chain {#secure-blockchain-voting} + +Gli schemi di voto della blockchain hanno molte caratteristiche favorevoli: sono interamente controllabili, sicuri contro gli attacchi, resistenti alla censura e liberi da vincoli geografici. Ma persino gli schemi di voto on-chain non sono immuni al problema della **collusione**. + +Definita come "azioni di coordinamento per limitare la competizione aperta ingannando, truffando e fuorviando gli altri", la collusione potrebbe assumere la forma di un utente malevolo che influenza il voto offrendo tangenti. Ad esempio, Alice potrebbe ricevere una tangente da Bob per votare per l'`opzione B` a scrutinio, anche se preferisce l'`opzione A`. + +Corruzione e collusione limitano l'efficiacia di qualsiasi processo che utilizzi il voto come meccanismo di indicazione (specialmente nei casi in cui gli utenti possono provare come hanno votato). Ciò può avere conseguenze significative, specialmente quando i voti determinano l'allocazione di risorse scarse. + +Ad esempio, i [meccanismi di finanziamento quadratico](https://www.radicalxchange.org/concepts/plural-funding/) si affidano alle donazioni per misurare la preferenza per certe opzioni, tra svariati progetti di interesse pubblico. Ogni donazione conta come un "voto" per un progetto specifico, e i progetti che ricevono il maggior numero di voti ottengono maggiori finanziamenti dal gruppo corrispondente. + +Utilizzare il voto on-chain espone il finanziamento quadratico alla collusione: le transazioni della blockchain sono pubbliche, quindi i corruttori possono ispezionare l'attività on-chain di un corrotto, per vedere come questi ha "votato". Così, i finanziamenti quadratici cessano di essere un mezzo efficiente per allocare fondi a seconda delle preferenze aggregate della community. + +Per fortuna, le nuove soluzioni, come la MACI (Infrastruttura Anti-Collusione Minima), utilizzano le prove a conoscenza zero per rendere il voto on-chain (es. i meccanismi di finanziamento quadratico) resistenti a corruzione e collusione. La MACI è una serie di contratti intelligenti e script che consentono a un amministratore centrale (detto "coordinatore") di aggregare voti e risultati _senza_ rivelare nulla sulle indicazioni di voto del singolo. Ciononostante, è ancora possibile verificare che i voti siano stati contati correttamente o confermare che un particolare individuo abbia partecipato al turno di votazioni. + +#### Come funziona MACI con prove a conoscenza zero? {#how-maci-works-with-zk-proofs} + +All'inizio, il coordinatore distribuisce il contratto della MACI su Ethereum, dopodiché gli utenti possono iscriversi al voto (registrando la propria chiave pubblica nel contratto intelligente). Gli utenti trasmettono i voti inviando messaggi crittografati con la propria chiave pubblica al contratto intelligente (un voto valido dev'essere firmato con la chiave pubblica più recente associata all'identità dell'utente, tra gli altri criteri). Dopodiché, il coordinatore elabora tutti i messaggi al termine del periodo di voto, conteggia i voti e verifica i risultati on-chain. + +Nella MACI, le prove a conoscenza zero sono utilizzate per assicurare la correttezza del calcolo, rendendo impossibile per il coordinatore elaborare erroneamente i voti e i risultati dei conteggi. Ciò si ottiene chiedendo al coordinatore di generare le prove ZK-SNARK, verificando che a) tutti i messaggi siano stati elaborati correttamente, b) il risultato finale corrisponda alla somma di tutti i voti _validi_. + +Dunque, anche senza condividere una ripartizione dei voti per utente (come avviene in genere), la MACI garantisce l'integrità dei risultati calcolati durante la procedura di conteggio. Questa funzionalità è utile nel ridurre l'efficacia degli schemi basilari di collusione. Possiamo esplorare questa possibilità utilizzando l'esempio precedente di Bob che corrompe Alice per votare per un'opzione: + +- Alice si registra per votare inviando la propria chiave pubblica a uno smart contract. +- Alice accetta di votare per l'`opzione B` in cambio di una tangente da Bob. +- Alice vota per l'`opzione B`. +- Alice invia segretamente una transazione cifrata per cambiare la chiave pubblica associata alla sua identità. +- Alice invia un altro messaggio (crittografato) allo smart contract votando per l'`opzione A ` utilizzando la nuova chiave pubblica. +- Alice mostra a Bob una transazione che mostra che ha votato per l'`opzione B` (che non è valida poiché la chiave pubblica non è più associata all'identità di Alice nel sistema) +- Elaborando i messaggi, il coordinatore salta il voto di Alice per `option B` e conteggia soltanto il voto per `option A`. Dunque, il tentativo di collusione di Bob con Alice e di manipolazione del voto on-chain fallisce. + +L'utilizzo di MACI _richiede_ la fiducia nel fatto che il coordinatore sia colluso con i corruttori, né tenti di corrompere gli stessi elettori. Il coordinatore può decifrare i messaggi degli utenti (operazione necessaria per creare la prova), così che possa verificare accuratamente il voto di ogni persona. + +Ma nei casi in cui il coordinatore rimane onesto, la MACI rappresenta un potente strumento a garanzia della legittimità del voto on-chain. Ciò spiega la sua popolarità tra le applicazioni di finanziamento quadratico (es., [clr.fund](https://clr.fund/#/about/maci)) che fanno molto affidamento sull'integrità delle scelte di voto di ogni individuo. + +Scopri di più riguardo a [MACI](https://github.com/privacy-scaling-explorations/maci/blob/master/specs/01_introduction.md). + +## Svantaggi dell'utilizzo delle prove a conoscenza zero {#drawbacks-of-using-zero-knowledge-proofs} + +### Costi hardware {#hardware-costs} + +Generare le prove a conoscenza zero comporta calcoli molto complessi, eseguiti meglio su macchine specializzate. Poiché tali macchine sono costose, sono spesso fuori dalla portata degli individui "normali". Inoltre, le applicazioni che desiderano utilizzare la tecnologia a conoscenza zero, devono tenere conto dei costi dell'hardware, che potrebbero incrementare i costi per gli utenti finali. + +### Costi di verifica delle prove {#proof-verification-costs} + +Inoltre, la verifica delle prove richiede calcoli complessi e incrementa i costi di implementazione della tecnologia a conoscenza zero nelle applicazioni. Questo costo è particolarmente importante nel contesto della prova del calcolo. Ad esempio, i rollup ZK pagano approssimativamente 500.000 gas per verificare una singola prova ZK-SNARK su Ethereum, mentre le ZK-STARK richiedono commissioni persino maggiori. + +### Ipotesi di fiducia {#trust-assumptions} + +Nelle ZN-SNARK, la Stringa di Riferimento Comune (parametri pubblici) è generata una volta ed è disponibile per il riutilizzo alle parti che desiderano partecipare al protocollo a conoscenza zero. I parametri pubblici sono creati tramite una cerimonia di configurazione attendibile, i cui partecipanti sono considerati onesti. + +Ma non esiste davvero un modo tramite cui gli utenti possano valutare l'onestà dei partecipanti e gli utenti devono prendere in parola gli sviluppatori. Le ZK-STARK sono libere da ipotesi di fiducia, poiché la casualità utilizzata nel generare la stringa è verificabile pubblicamente. Nel mentre, i ricercatori stanno lavorando a configurazioni non basate su fiducia per le ZK-SNARK, per aumentare la sicurezza dei meccanismi di prova. + +### Minacce del calcolo quantistico {#quantum-computing-threats} + +Le ZK-SNARK utilizzano la crittografia curva ellittica ([ECDSA](/glossary/#ecdsa)) per la crittografia. Sebbene l'algoritmo ECDSA sia sicuro al momento, lo sviluppo dei computer quantistici potrebbe infrangerne il modello di sicurezza, in futuro. + +Le ZK-STARK sono considerate immuni alla minaccia dei computer quantistici, poiché utilizzano hash resistenti alla collisione per la crittografia. A differenza delle coppie di chiavi pubbliche-private utilizzate nella crittografia curva ellittica, gli hash resistenti alla collisione sono più difficili da rompere per gli algoritmi dei computer quantistici. + +## Ulteriori letture {#further-reading} + +- [Professore Informatico spiega un concetto applicando fino a 5 livelli di difficolta | WIRED](https://www.youtube.com/watch?v=fOGdb1CTu5c) - _Wired YouTube channel_ +- [Panoramica dei casi d'uso per le prove a conoscenza zero](https://appliedzkp.org/#Projects): _Privacy and Scaling Explorations Team_ +- [SNARK vs. STARK vs. SNARK Ricorsivi](https://www.alchemy.com/overviews/snarks-vs-starks) _Alchemy Overviews_ +- [Una prova a conoscenza zero: migliorare la privacy su una Blockchain](https://www.altoros.com/blog/zero-knowledge-proof-improving-privacy-for-a-blockchain/): _Dmitry Lavrenov_ +- [zk-SNARK: un esempio e approfondimento realistico sulla conoscenza zero realistica](https://medium.com/coinmonks/zk-snarks-a-realistic-zero-knowledge-example-and-deep-dive-c5e6eaa7131c) — _Adam Luciano_ +- [ZK-STARK: creare fiducia verificabile, persino contro i computer quantistici](https://medium.com/coinmonks/zk-starks-create-verifiable-trust-even-against-quantum-computers-dd9c6a2bb13d) — _Adam Luciano_ +- [Un'introduzione approssimativa a come sono possibili le ZK-SNARK](https://vitalik.ca/general/2021/01/26/snarks.html).- _Vitalik Buterin_ +- [Cos'è la prova a conoscenza zero e qual è il suo ruolo nella Blockchain?](https://www.leewayhertz.com/zero-knowledge-proof-and-blockchain/) - _LeewayHertz_ diff --git a/src/content/translations/pt-br/bridges/index.md b/src/content/translations/pt-br/bridges/index.md index 434ee20c2d6..0cbd541916e 100644 --- a/src/content/translations/pt-br/bridges/index.md +++ b/src/content/translations/pt-br/bridges/index.md @@ -18,7 +18,7 @@ Vejamos um exemplo: Você é dos EUA e está planejando uma viagem à Europa. Você tem Dólar, mas precisa de Euro para gastar. Para trocar seus Dólares por Euros, você pode usar uma corretora de câmbio por uma pequena taxa. -Mas, o que você faz se quiser fazer uma troca parecida para usar um blockchain diferente? Digamos que você queira trocar ETH na rede principal Ethereum por ETH no [Arbitrum](https://arbitrum.io/). Como o câmbio de moedas que fizemos por Euro, precisamos de um mecanismo para mover nosso ETH do Ethereum para o Arbitrum. As pontes tornam essa transação possível. Neste caso,a [Arbitrum tem uma ponte nativa](https://bridge.arbitrum.io/) que pode transferir o ETH da rede principal para o Arbitrum. +Mas, o que você faz se quiser fazer uma troca parecida para usar um blockchain diferente? Digamos que você queira trocar ETH na rede principal Ethereum por ETH no [Arbitrum](https://arbitrum.io/). Como o câmbio de moedas que fizemos por Euro, precisamos de um mecanismo para mover nosso ETH do Ethereum para o Arbitrum. As pontes tornam essa transação possível. Neste caso, a [Arbitrum tem uma ponte nativa](https://bridge.arbitrum.io/) que pode transferir o ETH da rede principal para o Arbitrum. ## Por que precisamos de pontes? {#why-do-we-need-bridges} diff --git a/src/content/translations/pt-br/community/online/index.md b/src/content/translations/pt-br/community/online/index.md index 2cfeffb1252..e9dfbf2465a 100644 --- a/src/content/translations/pt-br/community/online/index.md +++ b/src/content/translations/pt-br/community/online/index.md @@ -26,11 +26,11 @@ Centenas de milhares de entusiastas do Ethereum se reúnem nestes fóruns na Int CryptoDevs – Comunidade Discord focada no desenvolvimento do Ethereum Discord EthStaker – Comunidade orientada para oferecer suporte no gerenciamento de projetos para o desenvolvimento do Ethereum Equipe do site Ethereum.org – pare e converse sobre desenvolvimento e design do site ethereum.org com a equipe e pessoas da comunidade -Matos Discord – comunidade de criadores da Web3 na qual construtores, lideranças industriais e entusiastas do Ethereum se encontram. Somos apaixonados pelo desenvolvimento, design e cultura web3. Venha criar conosco. -Solidity Gitter– chat para desenvolvimento do solidity (Gitter) -Solidity Matrix – chat para desenvolvimento do Solidity (Matrix) -Ethereum Stack Exchange _– fórum de perguntas e respostas_ -Peeranha _– fórum descentralizado de perguntas e respostas_ +Matos Discord – comunidade de criadores da Web3 na qual construtores, líderes do setor e entusiastas do Ethereum se encontram. Somos apaixonados pelo desenvolvimento, design e cultura Web3. Venha criar conosco. +Solidity Gitter — chat para desenvolvimento do solidity (Gitter) +Solidity Matrix — chat para desenvolvimento do solidity (Matrix) +Ethereum Stack Exchange _ — fórum de perguntas e respostas_ +Peeranha _ — fórum descentralizado de perguntas e respostas_ ## YouTube e Twitter {#youtube-and-twitter} diff --git a/src/content/translations/pt-br/community/support/index.md b/src/content/translations/pt-br/community/support/index.md index a6989001c41..b23bda172f8 100644 --- a/src/content/translations/pt-br/community/support/index.md +++ b/src/content/translations/pt-br/community/support/index.md @@ -42,6 +42,7 @@ Desevolver um dapp pode ser difícil. Aqui estão alguns espaços voltados ao de - [Discord CryptoDevs](https://discord.gg/Z9TA39m8Yu) - [Stackexchange do Ethereum](https://ethereum.stackexchange.com/) - [StackOverflow](https://stackoverflow.com/questions/tagged/web3) +- [Universidade Web3](https://www.web3.university/) Você também pode encontrar documentação e guias de desenvolvimento em nossa seção [Recursos de desenvolvedor Ethereum](/developers/). diff --git a/src/content/translations/pt-br/developers/docs/accounts/accounts.png b/src/content/translations/pt-br/developers/docs/accounts/accounts.png new file mode 100644 index 00000000000..4fa56527e42 Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/accounts/accounts.png differ diff --git a/src/content/translations/pt-br/developers/docs/apis/javascript/index.md b/src/content/translations/pt-br/developers/docs/apis/javascript/index.md index 366e3d0b0b5..a5fe3e33f70 100644 --- a/src/content/translations/pt-br/developers/docs/apis/javascript/index.md +++ b/src/content/translations/pt-br/developers/docs/apis/javascript/index.md @@ -10,7 +10,7 @@ Para esse propósito, cada cliente Ethereum implementa a especificação [JSON-R Se você quiser usar JavaScript para se conectar a um nó Ethereum, é possível usar o JavaScript vanilla, mas existem várias bibliotecas convenientes dentro do ecossistema que tornam isso muito mais fácil. Com essas bibliotecas, desenvolvedores podem escrever métodos intuitivos, one-line para inicializar solicitações JSON RPC (sob o capô) que interagem com Ethereum. -Note que desde a [A Fusão](/roadmap/merge/) (The Merge), duas partes conectadas do software Ethereum - um cliente de execução e um cliente de consenso - são necessárias para executar um nó. Certifique-se de que seu nó inclui tanto o cliente de execução quanto o consensual. Se o seu nó não estiver na sua máquina local (por exemplo, seu nó está sendo executado em uma instância da AWS) atualize os endereços IP no tutorial adequadamente. Para obter mais informações, veja nossa página no [executando um nó](/developers/docs/nodes-and-clients/run-a-node/). +Observe que, desde [A Fusão](/roadmap/merge/) (The Merge), duas partes conectadas do software Ethereum — um cliente de execução e um cliente de consenso — são necessárias para executar um nó. Certifique-se de que seu nó inclui tanto o cliente de execução quanto o consensual. Se o seu nó não estiver na sua máquina local (por exemplo, seu nó está sendo executado em uma instância da AWS) atualize os endereços IP no tutorial adequadamente. Para obter mais informações, veja nossa página no [executando um nó](/developers/docs/nodes-and-clients/run-a-node/). ## Pré-requisitos {#prerequisites} diff --git a/src/content/translations/pt-br/developers/docs/apis/json-rpc/index.md b/src/content/translations/pt-br/developers/docs/apis/json-rpc/index.md index e2fa1473281..aeba6a88ff0 100644 --- a/src/content/translations/pt-br/developers/docs/apis/json-rpc/index.md +++ b/src/content/translations/pt-br/developers/docs/apis/json-rpc/index.md @@ -6,7 +6,7 @@ lang: pt-br Para que um aplicativo de software interaja com a blockchain Ethereum - lendo os dados da blockchain ou enviando transações para a rede - ele deve se conectar na Ethereum. -Para isso, cada [cliente Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implementa uma [especificação JSON-RPC](https://github.com/ethereum/execution-apis), portanto, há um conjunto uniforme de métodos nos quais os aplicativos podem confiar, independentemente do nó específico ou da implementação do cliente. +Para esse fim, todos os [clientes Ethereum](/developers/docs/nodes-and-clients/#execution-clients) implementam uma [especificação JSON-RPC](https://github.com/ethereum/execution-apis) para que exista um conjunto uniforme de métodos nos quais os aplicativos podem confiar, independentemente do nó específico ou da implementação do cliente. [JSON-RPC](https://www.jsonrpc.org/specification) é um protocolo de chamada de procedimento remoto (RPC) leve e sem estado. Ele define várias estruturas de dados e as regras em torno de seu processamento. É agnóstico de transporte no sentido de que os conceitos podem ser usados dentro do mesmo processo, sobre sockets, HTTP ou em vários ambientes de passagem de mensagens. Usa o formato de dados JSON (RFC 4627). @@ -22,7 +22,7 @@ Embora você possa optar por interagir diretamente com clientes da Ethereum usan Esta página trata principalmente da API JSON-RPC usada pelos clientes de execução Ethereum. No entanto, os clientes de consenso também têm uma API RPC que permite aos usuários consultar informações sobre o nó, solicitar blocos Beacon, estado do Beacon, e outras informações relacionadas ao consenso diretamente de um nó. Essa API está documentada na [página da Web da API Beacon](https://ethereum.github.io/beacon-APIs/#/). -Uma API interna também é usada para comunicação entre clientes dentro de um nó - ou seja, permite que o cliente de consenso e o cliente de execução troquem dados. Isso é chamado de 'Engine API' e as especificações estão disponíveis no [Github](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). +Uma API interna também é usada para comunicação entre clientes dentro de um nó - ou seja, permite que o cliente de consenso e o cliente de execução troquem dados. Ela é chamada de “API Engine” e suas especificações estão disponíveis no [Github](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). ## Especificação do cliente de execução {#spec} @@ -200,7 +200,11 @@ Nenhum `String` - A id da rede atual. -A lista completa das IDs da rede atual está disponível em [chainlist.org](https://chainlist.org). Alguns comuns são: `1`: Ethereum Mainnet `2`: Rede de teste Morden (agora obsoleta) `3`: Rede de teste Ropsten `4`: Rede de teste Rinkeby `5`: Rede de teste Goerli +A lista completa das IDs da rede atual está disponível em [chainlist.org](https://chainlist.org). Alguns exemplos comuns são: + +- `1`: Ethereum Mainnet +- `5`: Goerli testnet +- `11155111`: Sepolia testnet **Exemplo** @@ -302,9 +306,9 @@ Nenhum `Object|Boolean`, um objeto com dados de status da sincronização ou `FALSE`, quando não sincronizado: -- `startingBlock`: `QUANTITY` - O bloco em que a importação começou (só será reiniciado, após a sincronização atingir seu cabeçalho) -- `currentBlock`: `QUANTITY` - O bloco atual, o mesmo que eth_blockNumber -- `highestBlock`: `QUANTITY` - O bloco mais alto estimado +- `startingBlock`: `QUANTITY` — O bloco no qual a importação começou (só será reiniciado após a sincronização atingir seu cabeçalho) +- `currentBlock`: `QUANTITY` — O bloco atual, o mesmo que eth_blockNumber +- `highestBlock`: `QUANTITY` — O bloco mais alto estimado **Exemplo** @@ -354,6 +358,31 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":6 } ``` +## eth_chainId {#eth_chainId} + +Retorna a ID da cadeia usada para assinar transações protegidas contra reprodução. + +**Parâmetros** + +Nenhum + +**Retorna** + +`chainId`, valor hexadecimal como uma cadeia de caracteres representando o inteiro da ID da cadeia atual. + +**Exemplo** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "0x1" +} +``` + ### eth_mining {#eth_mining} Retorna `true` se o cliente estiver ativamente minerando novos blocos. @@ -364,7 +393,7 @@ Nenhum **Retorna** -`Boolean` - retorna `true` do cliente que está minerando, caso contrário, `false`. +`Boolean` — retorna `true` do cliente que está minerando, caso contrário, `false`. **Exemplo** @@ -389,7 +418,7 @@ Nenhum **Retorna** -`QUANTITY` - número de hashes por segundo. +`QUANTITY` — número de hashes por segundo. **Exemplo** @@ -406,7 +435,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_hashrate","params":[],"id":7 ### eth_gasPrice {#eth_gasprice} -Retorna o preço atual por gás em wei. +Retorna o preço atual por gás em Wei. **Parâmetros** @@ -414,7 +443,7 @@ Nenhum **Retorna** -`QUANTITY` - Número inteiro do preço atual do gás em wei. +`QUANTITY` — Número inteiro do preço atual do gás em Wei. **Exemplo** @@ -439,7 +468,7 @@ Nenhum **Retorna** -`Array de DADOS`, 20 Bytes - endereços de propriedade do cliente. +`Matriz de DADOS`, 20 Bytes — endereços de propriedade do cliente. **Exemplo** @@ -464,7 +493,7 @@ Nenhum **Retorna** -`QUANTITY` - Inteiro do número do bloco atual em que o cliente está. +`QUANTITY` — Inteiro do número do bloco atual no qual o cliente está. **Exemplo** @@ -494,7 +523,7 @@ params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"] **Retorna** -`QUANTITY` - Inteiro do saldo atual em wei. +`QUANTITY` — Inteiro do saldo atual em Wei. **Exemplo** @@ -511,7 +540,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407 ### eth_getStorageAt {#eth_getstorageat} -Retorna o valor de uma posição de armazenamento em determinado endereço. +Retorna o valor de uma posição de armazenamento em um determinado endereço. **Parâmetros** @@ -521,9 +550,9 @@ Retorna o valor de uma posição de armazenamento em determinado endereço. **Retorna** -`DATA` - O valor nessa posição de armazenamento. +`DATA` — O valor nessa posição de armazenamento. -**Exemplo** Calcular a posição correta depende do armazenamento para recuperar. Considere o seguinte contrato implementado em `0x295a70b2de5e3953354a6a8344e616ed314d7251` pelo endereço `0x391694e7e0b0cce554cb130d723a9d27458f9298`. +**Exemplo** O cálculo da posição correta depende do armazenamento a ser recuperado. Considere o seguinte contrato implementado em `0x295a70b2de5e3953354a6a8344e616ed314d7251` pelo endereço `0x391694e7e0b0cce554cb130d723a9d27458f9298`. ``` contract Storage { @@ -536,7 +565,7 @@ contract Storage { } ``` -Recuperar o valor do pos0 é simples: +Recuperar o valor da pos0 é simples: ```js curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545 @@ -549,7 +578,7 @@ Recuperar um elemento do mapa é mais difícil. A posição de um elemento no ma keccack(LeftPad32(key, 0), LeftPad32(map position, 0)) ``` -Isso significa que para recuperar o armazenamento no pos1["0x391694e7e0b0cce554cb130d723a9d27458f9298"] precisamos calcular a posição com: +Isso significa que, para recuperar o armazenamento na pos1["0x391694e7e0b0cce554cb130d723a9d27458f9298"] precisamos calcular a posição com: ```js keccak( @@ -560,7 +589,7 @@ keccak( ) ``` -O console geth que vem com a biblioteca web3 pode ser usado para fazer o cálculo: +O console geth fornecido com a biblioteca Web3 pode ser usado para fazer o cálculo: ```js > var key = "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001" @@ -569,7 +598,7 @@ undefined "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9" ``` -Agora para pegar o armazenamento: +Agora, para buscar o armazenamento: ```js curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"], "id": 1}' localhost:8545 @@ -594,7 +623,7 @@ params: [ **Retorna** -`QUANTITY` - Inteiro do número de transações enviadas a partir deste endereço. +`QUANTITY` — Inteiro do número de transações enviadas a partir desse endereço. **Exemplo** @@ -623,7 +652,7 @@ params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] **Retorna** -`QUANTITY` - Inteiro do número de transações neste bloco. +`QUANTITY` — Inteiro do número de transações nesse bloco. **Exemplo** @@ -654,7 +683,7 @@ params: [ **Retorna** -`QUANTIDADE` - Número inteiro de transações neste bloco. +`QUANTITY` — Inteiro do número de transações nesse bloco. **Exemplo** @@ -683,7 +712,7 @@ params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] **Retorna** -`QUANTITY` - Inteiro do número de transações neste bloco. +`QUANTITY` — Inteiro do número de transações nesse bloco. **Exemplo** @@ -714,7 +743,7 @@ params: [ **Retorna** -`QUANTIDADE` - Número inteiro de transações neste bloco. +`QUANTITY` — Inteiro do número de transações nesse bloco. **Exemplo** @@ -731,7 +760,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockNumber", ### eth_getCode {#eth_getcode} -Retorna código em determinado endereço. +Retorna o código em um endereço fornecido. **Parâmetros** @@ -747,7 +776,7 @@ params: [ **Retorna** -`DATA` - O código do endereço fornecido. +`DATA` — O código do endereço fornecido. **Exemplo** @@ -764,11 +793,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCode","params":["0xa94f53 ### eth_sign {#eth_sign} -O método sign calcula uma assinatura específica da Ethereum com: `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`. +O método de assinatura calcula uma assinatura específica do Ethereum com: `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`. -Ao adicionar um prefixo à mensagem, a assinatura calculada é reconhecível como uma assinatura específica da Ethereum. Isso previne o uso indevido em que um dapp malicioso pode assinar dados arbitrários (por exemplo, de transação) e usar a assinatura para personificar a vítima. +Ao adicionar um prefixo à mensagem, a assinatura calculada é reconhecível como uma assinatura específica do Ethereum. Isso evita o uso indevido por parte de um dapp malicioso, que pode assinar dados arbitrários (por exemplo, de transação) e usar a assinatura para usar a identidade da vítima. -Nota: o endereço de assinatura deve estar desbloqueado. +Observação: o endereço de assinatura deve estar desbloqueado. **Parâmetros** @@ -777,7 +806,7 @@ Nota: o endereço de assinatura deve estar desbloqueado. **Retorna** -`DATA`: Assinatura +`DATA`: assinatura **Exemplo** @@ -800,17 +829,17 @@ Assina uma transação que pode ser enviada à rede posteriormente usando [eth_s 1. `Objeto` - O objeto da transação -- `from`: `DATA`, 20 Bytes - Endereço de onde a transação é enviada. -- `to`: `DATA`, 20 Bytes - (Opcional ao criar um novo contrato) O endereço para o qual a transação é direcionada. -- `gas`: `QUANTITY` - (Opcional, padrão: 90000) Inteiro do gás fornecido para a execução da transação. Retornará o gás não utilizado. -- `gasPrice`: `QUANTITY` - (Opcional, padrão: a ser determinado) Inteiro do gasPrice usado para cada gás pago, em Wei. -- `valor`: `QUANTITY` - (Opcional) Inteiro do valor enviado com esta transação, em Wei. -- `data`: `DATA` - Código compilado de um contrato OU o hash da assinatura do método invocado e parâmetros codificados. -- `nonce`: `QUANTITY` - (Opcional) Inteiro de um nonce. Isso permite sobrescrever suas próprias transações pendentes que usam o mesmo nonce. +- `from`: `DATA`, 20 Bytes - O endereço de onde a transação é enviada. +- `to`: `DATA`, 20 Bytes - (opcional ao criar um novo contrato) O endereço para o qual a transação é direcionada. +- `gas`: `QUANTITY` - (opcional, padrão: 90000) Inteiro do gás fornecido para a execução da transação. Retornará o gás não utilizado. +- `gasPrice`: `QUANTITY` — (opcional, padrão: a ser determinado) Inteiro do gasPrice usado para cada gás pago, em Wei. +- `valor`: `QUANTITY` — (opcional) Inteiro do valor enviado com esta transação, em Wei. +- `dados`: `DADOS` - O código compilado de um contrato OU o hash da assinatura do método invocado e os parâmetros codificados. +- `nonce`: `QUANTITY` - (opcional) Inteiro de um nonce. Isso permite sobrescrever suas próprias transações pendentes que usam o mesmo nonce. **Retorna** -`DATA` - O objeto de transação assinada. +`DATA` — O objeto da transação assinada. **Exemplo** @@ -833,13 +862,13 @@ Cria uma nova transação de chamada de mensagem ou uma criação de contrato, s 1. `Object` - O objeto da transação -- `from`: `DATA`, 20 Bytes - O endereço de onde a transação é enviada. -- `to`: `DATA`, 20 Bytes - (opcional ao criar um novo contrato) O endereço para o qual a transação é direcionada. -- `gas`: `QUANTITY` - (opcional, padrão: 90000) Inteiro do gás fornecido para a execução da transação. Retornará o gás não utilizado. -- `gasPrice`: `QUANTITY` - (Opcional, padrão: A ser determinado) Inteiro do gasPrice usado para cada gás pago. -- `valor`: `QUANTITY` - (Opcional) Inteiro do valor enviado com esta transação. -- `dados`: `DADOS` - O código compilado de um contrato OU o hash da assinatura do método invocado e os parâmetros codificados. -- `nonce`: `QUANTITY` - (opcional) Inteiro de um nonce. Isso permite sobrescrever suas próprias transações pendentes que usam o mesmo nonce. +- `from`: `DATA`, 20 Bytes — Endereço de onde a transação é enviada. +- `to`: `DATA`, 20 Bytes — (opcional ao criar um novo contrato) O endereço para o qual a transação é direcionada. +- `gas`: `QUANTITY` — (opcional, padrão: 90000) Inteiro do gás fornecido para a execução da transação. Retornará o gás não utilizado. +- `gasPrice`: `QUANTITY` — (opcional, padrão: a ser determinado) Inteiro do gasPrice usado para cada gás pago. +- `valor`: `QUANTITY` — (opcional) Inteiro do valor enviado com esta transação. +- `data`: `DATA` — Código compilado de um contrato OU do hash da assinatura do método invocado e parâmetros codificados. +- `nonce`: `QUANTITY` — (opcional) Inteiro de um nonce. Isso permite substituir suas próprias transações pendentes que usam o mesmo nonce. ```js params: [ @@ -856,9 +885,9 @@ params: [ **Retorna** -`DATA`, 32 Bytes - O hash da transação ou o hash zero se a transação ainda não estiver disponível. +`DATA`, 32 bytes - o hash da transação ou o hash zero se a transação ainda não estiver disponível. -Use [eth_getTransactionReceipt](#eth_gettransactionreceipt) para obter o endereço do contrato, depois que a transação foi minerada, quando você criou um contrato. +Use [eth_getTransactionReceipt](#eth_gettransactionreceipt) para obter o endereço do contrato, após a transação ter sido minerada, quando você criou um contrato. **Exemplo** @@ -875,7 +904,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendTransaction","params":[{ ### eth_sendRawTransaction {#eth_sendrawtransaction} -Cria uma nova transação de chamada de mensagem ou uma criação de contrato para transações assinadas. +Cria uma nova transação de chamada de mensagem ou um contrato para transações assinadas. **Parâmetros** @@ -889,7 +918,7 @@ params: [ **Retorna** -`DATA`, 32 bytes - o hash da transação ou o hash zero se a transação ainda não estiver disponível. +`DATA`, 32 Bytes — O hash da transação ou o hash zero se a transação ainda não estiver disponível. Use [eth_getTransactionReceipt](#eth_gettransactionreceipt) para obter o endereço do contrato, após a transação ter sido minerada, quando você criou um contrato. @@ -914,18 +943,18 @@ Executa uma nova chamada de mensagem imediatamente sem criar uma transação na 1. `Object` - O objeto de chamada de transação -- `from`: `DATA`, 20 Bytes - (Opcional) O endereço de onde a transação é enviada. -- `to`: `DATA`, 20 Bytes - O endereço para o qual a transação é direcionada. -- `gas`: `QUANTITY` - (Opcional) Inteiro do gás fornecido para a execução da transação. eth_call consome zero gás, mas este parâmetro pode ser necessário para algumas execuções. -- `gasPrice`: `QUANTITY` - (Opcional) Inteiro do gasPrice usado para cada gás pago -- `valor`: `QUANTITY` - (Opcional) Inteiro do valor enviado com esta transação -- `data`: `DATA` - (Opcional) Hash da assinatura do método e parâmetros codificados. Para obter mais detalhes, consulte [Contrato Ethereum ABI na documentação do Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html) +- `from`: `DATA`, 20 Bytes — (opcional) O endereço a partir do qual a transação é enviada. +- `to`: `DATA`, 20 Bytes — O endereço para o qual a transação é direcionada. +- `gas`: `QUANTITY` — (opcional) Inteiro do gás fornecido para a execução da transação. eth_call consome zero gás, mas este parâmetro pode ser necessário para algumas execuções. +- `gasPrice`: `QUANTITY` — (opcional) Inteiro do gasPrice usado para cada gás pago +- `valor`: `QUANTITY` — (opcional) Inteiro do valor enviado com esta transação +- `data`: `DATA` — (opcional) Hash da assinatura do método e parâmetros codificados. Para obter mais detalhes, consulte o [Contrato Ethereum ABI na documentação do Solidity](https://docs.soliditylang.org/en/latest/abi-spec.html) 2. `QUANTITY|TAG` – número de bloco inteiro, ou a cadeia de caracteres `"latest"`, `"earliest"` ou `"pending"`. Consulte o [parâmetro de bloco padrão](/developers/docs/apis/json-rpc/#default-block) **Retorna** -`DATA` - O valor de retorno do contrato executado. +`DATA` — O valor de retorno do contrato executado. **Exemplo** @@ -942,15 +971,15 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}] ### eth_estimateGas {#eth_estimategas} -Gera e retorna uma estimativa de quanto gás é necessário para permitir que a transação seja concluída. A transação não será adicionada à blockchain. Observe que a estimativa pode ser significativamente maior do que a quantidade de gás realmente usada pela transação, por vários motivos, incluindo a mecânica da EVM e o desempenho do nó. +Gera e retorna uma estimativa de quanto gás é necessário para permitir que a transação seja concluída. A transação não será adicionada à blockchain. Observe que a estimativa pode ser significativamente maior do que a quantidade de gás realmente usada pela transação, por vários motivos, incluindo a mecânica do EVM e o desempenho do nó. **Parâmetros** -Veja os parâmetros [eth_call](#eth_call), exceto que todas as propriedades são opcionais. Se nenhum limite de gás for especificado, o geth usa o limite de gás do bloco pendente como limite superior. Como resultado, a estimativa retornada pode não ser suficiente para executar a chamada/transação quando a quantidade de gás for maior que o limite de gás do bloco pendente. +Veja os parâmetros do [eth_call](#eth_call), embora todas as propriedades sejam opcionais. Se nenhum limite de gás for especificado, o geth usa o limite de gás do bloco pendente como um limite superior. Consequentemente, a estimativa retornada poderá não ser suficiente para executar a chamada/transação quando a quantidade de gás for maior que o limite de gás do bloco pendente. **Retorna** -`QUANTITY` - A quantidade de gás usada. +`QUANTITY` — A quantidade de gás usada. **Exemplo** @@ -983,27 +1012,27 @@ params: [ **Retorna** -`Object` - Um objeto de bloco, ou `null` quando nenhum bloco foi encontrado: - -- `number`: `QUANTITY` - O número do bloco. `null` quando seu bloco pendente. -- `hash`: `DATA`, 32 Bytes - Hash do bloco. `null` quando seu bloco pendente. -- `parentHash`: `DATA`, 32 Bytes - Hash do bloco pai. -- `nonce`: `DATA`, 8 Bytes - Hash da prova de trabalho gerada. `null` quando seu bloco pendente. -- `sha3Uncles`: `DATA`, 32 Bytes - SHA3 dos dados tios no bloco. -- `logsBloom`: `DATA`, 256 Bytes - O filtro bloom para os logs do bloco. `null` quando seu bloco pendente. -- `transactionsRoot`: `DATA`, 32 Bytes - A raiz da árvore de transação do bloco. -- `stateRoot`: `DATA`, 32 Bytes - A raiz do estado de triagem final do bloco. -- `receiptsRoot`: `DATA`, 32 Bytes - A raiz da triagem dos recibos do bloco. -- `miner`: `DATA`, 20 Bytes - O endereço do beneficiário a quem as recompensas de mineração foram dadas. -- `dificuldade`: `QUANTITY` - Inteiro da dificuldade para este bloco. -- `totalDifficulty`: `QUANTITY` - Inteiro da dificuldade total da cadeia até este bloco. -- `extraData`: `DATA` - O campo "dados extras" deste bloco. -- `size`: `QUANTITY` - Inteiro do tamanho deste bloco em bytes. -- `gasLimit`: `QUANTITY` - O gás máximo permitido neste bloco. -- `gasUsed`: `QUANTITY` - O total de gás usado por todas as transações neste bloco. -- `timestamp`: `QUANTITY` - O timestamp unix para quando o bloco foi agrupado. -- `transactions`: `Array` - Matriz de objetos de transação ou hashes de transação de 32 bytes dependendo do último parâmetro fornecido. -- `uncles`: `Array` - Matriz de hashes tio (bloco). +`Object` — Um objeto de bloco, ou `null` quando nenhum bloco foi encontrado: + +- `number`: `QUANTITY` — O número do bloco. `null` quando o bloco está pendente. +- `hash`: `DATA`, 32 Bytes — Hash do bloco. `null` quando o bloco está pendente. +- `parentHash`: `DATA`, 32 Bytes — Hash do bloco pai. +- `nonce`: `DATA`, 8 Bytes — Hash da prova de trabalho gerada. `null` quando o bloco está pendente. +- `sha3Uncles`: `DATA`, 32 Bytes — SHA3 dos dados tios no bloco. +- `logsBloom`: `DATA`, 256 Bytes — O filtro bloom para os logs do bloco. `null` quando o bloco está pendente. +- `transactionsRoot`: `DATA`, 32 Bytes — A raiz da árvore de transação do bloco. +- `stateRoot`: `DATA`, 32 Bytes — A raiz da árvore do estado final do bloco. +- `receiptsRoot`: `DATA`, 32 Bytes — A raiz da árvore de itens recebidos do bloco. +- `miner`: `DATA`, 20 Bytes — O endereço do beneficiário a quem as recompensas de mineração foram dadas. +- `dificuldade`: `QUANTITY` — Inteiro da dificuldade para este bloco. +- `totalDifficulty`: `QUANTITY` — Inteiro da dificuldade total da cadeia até este bloco. +- `extraData`: `DATA` — O campo “dados extras” deste bloco. +- `size`: `QUANTITY` — Inteiro do tamanho deste bloco em bytes. +- `gasLimit`: `QUANTITY` — O gás máximo permitido neste bloco. +- `gasUsed`: `QUANTITY` — O total de gás usado por todas as transações neste bloco. +- `timestamp`: `QUANTITY` — O carimbo de data/hora unix no momento em que o bloco foi agrupado. +- `transactions`: `Array` — Matriz de objetos de transação ou hashes de transação de 32 bytes, dependendo do último parâmetro fornecido. +- `uncles`: `Array` — Matriz de hashes tio. **Exemplo** @@ -1058,7 +1087,7 @@ params: [ ] ``` -**Retorna** Consulte [eth_getBlockByHash](#eth_getblockbyhash) +**Retorno** Consulte [eth_getBlockByHash](#eth_getblockbyhash) **Exemplo** @@ -1067,7 +1096,7 @@ params: [ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x1b4", true],"id":1}' ``` -Resultado veja [eth_getBlockByHash](#eth_getblockbyhash) +Veja o resultado [eth_getBlockByHash](#eth_getblockbyhash) ### eth_getTransactionByHash {#eth_gettransactionbyhash} @@ -1083,22 +1112,22 @@ params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"] **Retorna** -`Object` - Um objeto de transação ou `null` quando nenhuma transação foi encontrada: - -- `blockHash`: `DATA`, 32 Bytes - hash do bloco onde esta transação estava. `null` quando está pendente. -- `blockNumber`: `QUANTITY` - número do bloco onde esta transação estava. `null` quando está pendente. -- `from`: `DATA`, 20 Bytes - Endereço do remetente. -- `gás`: `QUANTITY` - Gás fornecido pelo remetente. -- `gasPrice`: `QUANTITY` - Preço do gás fornecido pelo remetente em Wei. -- `hash`: `DATA`, 32 Bytes - Hash da transação. -- `input`: `DATA` - Os dados enviados junto com a transação. -- `nonce`: `QUANTITY` - O número de transações feitas pelo remetente antes desta. -- `to`: `DATA`, 20 Bytes - Endereço do destinatário. `null` quando for uma transação de criação de contrato. -- `transactionIndex`: `QUANTITY` - Inteiro da posição do índice de transações no bloco. `null` quando está pendente. -- `valor`: `QUANTITY` - Valor transferido em Wei. -- `v`: `QUANTITY` - ID de recuperação ECDSA -- `r`: `QUANTITY` - Assinatura ECDSA r -- `s`: `QUANTITY` - Assinatura ECDSA s +`Object` — Um objeto de transação ou `null` quando nenhuma transação foi encontrada: + +- `blockHash`: `DATA`, 32 Bytes — Hash do bloco onde esta transação estava localizada. `null` quando está pendente. +- `blockNumber`: `QUANTITY` — Número do bloco onde esta transação estava localizada. `null` quando está pendente. +- `from`: `DATA`, 20 Bytes — Endereço do remetente. +- `gás`: `QUANTITY` — Gás fornecido pelo remetente. +- `gasPrice`: `QUANTITY` — Preço do gás fornecido pelo remetente em Wei. +- `hash`: `DATA`, 32 Bytes — Hash da transação. +- `input`: `DATA` — Os dados enviados com a transação. +- `nonce`: `QUANTITY` — O número de transações feitas pelo remetente antes desta. +- `to`: `DATA`, 20 Bytes — Endereço do destinatário. `null` quando for uma transação de criação de contrato. +- `transactionIndex`: `QUANTITY` — Inteiro da posição do índice de transações no bloco. `null` quando está pendente. +- `valor`: `QUANTITY` — Valor transferido em Wei. +- `v`: `QUANTITY` — ID de recuperação ECDSA +- `r`: `QUANTITY` — Assinatura ECDSA r +- `s`: `QUANTITY` — Assinatura ECDSA s **Exemplo** @@ -1130,7 +1159,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","param ### eth_getTransactionByBlockHashAndIndex {#eth_gettransactionbyblockhashandindex} -Retorna informações sobre uma transação por hash de bloco e posição do índice de transação. +Retorna informações sobre uma transação por hash de bloco e a posição do índice de transação. **Parâmetros** @@ -1171,7 +1200,7 @@ params: [ ] ``` -**Retorna** Veja [eth_getTransactionByHash](#eth_gettransactionbyhash) +**Retorna** Consulte [eth_getTransactionByHash](#eth_gettransactionbyhash) **Exemplo** @@ -1184,9 +1213,9 @@ Resultado veja [eth_getTransactionByHash](#eth_gettransactionbyhash) ### eth_getTransactionReceipt {#eth_gettransactionreceipt} -Retorna o recibo de uma transação pelo hash de transação. +Retorna o recebimento de uma transação pelo hash de transação. -**Note** Que o recibo não está disponível para transações pendentes. +**Observe** que o recibo não está disponível para transações pendentes. **Parâmetros** @@ -1196,23 +1225,23 @@ Retorna o recibo de uma transação pelo hash de transação. params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"] ``` -**Retorna** `Object` - Um objeto de recibo de transação ou `null` quando nenhum recibo foi encontrado: - -- `transactionHash`: `DATA`, 32 Bytes - Hash da transação. -- `transactionIndex`: `QUANTITY` - inteiro da posição do índice de transações no bloco. -- `blockHash`: `DATA`, 32 Bytes - hash do bloco onde esta transação estava. -- `blockNumber`: `QUANTITY` - número do bloco onde esta transação estava. -- `from`: `DATA`, 20 Bytes - endereço do remetente. -- `to`: `DATA`, 20 Bytes - endereço do receptor. null quando for uma transação de criação de contrato. -- `cumulativeGasUsed` : `QUANTITY` - A quantidade total de gás utilizada quando esta transação foi executada no bloco. -- `effectiveGasPrice` : `QUANTITY` - A soma da taxa base e gorjeta paga por unidade de gás. -- `gasUsed`: `QUANTITY` - A quantidade de gás usada apenas por esta transação específica. -- `contractAddress`: `DATA`, 20 Bytes - O endereço do contrato criado, se a transação foi uma criação do contrato, caso contrário `null`. -- `logs`: `Array` - Matriz de objetos de log, que esta transação gerou. -- `logsBloom`: `DATA`, 256 Bytes - Filtro Bloom para clientes leves para recuperar rapidamente os logs relacionados. -- `type`: `DATA` - Inteiro do tipo de transação, `0x00` para transações herdadas, `0x01` para tipos de lista de acesso, `0x02` para taxas dinâmicas. Ele também retorna _either_ : -- `root` : `DATA` 32 bytes de stateroot pós-transação (pré-Bizantino) -- `status`: `QUANTITY` qualquer `1` (sucesso) ou `0` (falha) +**Retorna** `Object` — Um objeto de recebimento de transação, ou `null` quando nenhum recebimento foi encontrado: + +- `transactionHash`: `DATA`, 32 Bytes — Hash da transação. +- `transactionIndex`: `QUANTITY` — Inteiro da posição do índice de transações no bloco. +- `blockHash`: `DATA`, 32 Bytes — Hash do bloco onde esta transação estava localizada. +- `blockNumber`: `QUANTITY` — Número do bloco onde esta transação estava localizada. +- `from`: `DATA`, 20 Bytes — Endereço do remetente. +- `to`: `DATA`, 20 Bytes — Endereço do destinatário. null quando for uma transação de criação de contrato. +- `cumulativeGasUsed` : `QUANTITY` — A quantidade total de gás utilizada quando esta transação foi executada no bloco. +- `effectiveGasPrice` : `QUANTITY` — A soma da taxa base e gorjeta pagas por unidade de gás. +- `gasUsed`: `QUANTITY` — A quantidade de gás usada apenas por esta transação específica. +- `contractAddress`: `DATA`, 20 Bytes — O endereço do contrato criado, se a transação era uma criação do contrato, caso contrário `null`. +- `logs`: `Array` — Matriz de objetos de log gerados por esta transação. +- `logsBloom`: `DATA`, 256 Bytes — Filtro Bloom para clientes leves para recuperar rapidamente os logs relacionados. +- `type`: `QUANTITY` — Inteiro do tipo de transação, `0x0` para transações herdadas, `0x1` para tipos de lista de acesso, `0x2` para taxas dinâmicas. Ele também retorna _seja_ : +- `root` : `DATA` 32 bytes de stateRoot pós-transação (anterior à atualização Byzantium) +- `status`: `QUANTITY` seja `1` (êxito) ou `0` (falha) **Exemplo** @@ -1248,7 +1277,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","para ### eth_getUncleByBlockHashAndIndex {#eth_getunclebyblockhashandindex} -Retorna informações sobre um tio de um bloco por hash e posição de índice tio. +Retorna informações sobre o tio de um bloco por hash e a posição do índice de um tio. **Parâmetros** @@ -1262,7 +1291,7 @@ params: [ ] ``` -**Retorno** Consulte [eth_getBlockByHash](#eth_getblockbyhash) +**Retorna** Consulte [eth_getBlockByHash](#eth_getblockbyhash) **Exemplo** @@ -1271,9 +1300,9 @@ params: [ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex","params":["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", "0x0"],"id":1}' ``` -Resultado veja [eth_getBlockByHash](#eth_getblockbyhash) +Veja o resultado [eth_getBlockByHash](#eth_getblockbyhash) -**Nota**: Um tio (bloco) não contém transações individuais. +**Observação**: um tio (bloco) não contém transações individuais. ### eth_getUncleByBlockNumberAndIndex {#eth_getunclebyblocknumberandindex} @@ -1291,9 +1320,9 @@ params: [ ] ``` -**Retorna** Consulte [eth_getBlockByHash](#eth_getblockbyhash) +**Retorno** Consulte [eth_getBlockByHash](#eth_getblockbyhash) -**Nota**: um tio (bloco) não contém transações individuais. +**Observação**: um tio (bloco) não contém transações individuais. **Exemplo** @@ -1302,15 +1331,15 @@ params: [ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockNumberAndIndex","params":["0x29c", "0x0"],"id":1}' ``` -Resultado veja [eth_getBlockByHash](#eth_getblockbyhash) +Veja o resultado [eth_getBlockByHash](#eth_getblockbyhash) ### eth_getCompilers {#eth_getcompilers} Retorna uma lista de compiladores disponíveis no cliente. -**Parâmetros** None (Nenhum) +**Parâmetros** Nenhum -**Retorna** `Array` - Matriz de compiladores disponíveis. +**Retorna** `Array` — Matriz de compiladores disponíveis. **Exemplo** @@ -1327,7 +1356,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCompilers","params":[],"i ### eth_compileSolidity {#eth_compile_solidity} -Retorna o código solidity compilado. +Retorna o código Solidity compilado. **Parâmetros** @@ -1339,7 +1368,7 @@ params: [ ] ``` -**Retorna** `DATA` - O código fonte compilado. +**Retorna** `DATA` — O código-fonte compilado. **Exemplo** @@ -1398,7 +1427,7 @@ Retorna código LLL compilado. params: ["(returnlll (suicide (caller)))"] ``` -**Retorna** `DADOS` - O código fonte compilado. +**Retorna** `DATA` — O código-fonte compilado. **Exemplo** @@ -1425,7 +1454,7 @@ Retorna o código Serpent compilado. params: ["/* some serpent */"] ``` -**Retorna** `DADOS` - O código fonte compilado. +**Retorna** `DATA` — O código-fonte compilado. **Exemplo** @@ -1442,23 +1471,23 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileSerpent","params":["/ ### eth_newFilter {#eth_newfilter} -Cria um objeto de filtro, com base nas opções de filtro, para notificar quando o estado for alterado (logs). Para verificar se o estado mudou, chame [eth_getFilterChanges](#eth_getfilterchanges). +Cria um objeto de filtro, com base nas opções de filtro, para notificar quando o estado é alterado (logs). Para verificar se o estado mudou, chame [eth_getFilterChanges](#eth_getfilterchanges). -**Uma nota sobre a especificação de filtros de tópicos:** Os tópicos são dependentes da ordem. Uma transação com um log com tópicos [A, B] será combinada pelos seguintes filtros de tópicos: +**Observação sobre a especificação de filtros de tópicos:** Os tópicos são dependentes da ordem. Uma transação com um log com tópicos [A, B] será combinada pelos seguintes filtros de tópicos: -- `[]` "qualquer coisa" -- `[A]` "A na primeira posição (e qualquer coisa depois)" -- `[null, B]` "qualquer coisa na primeira posição AND o B na segunda posição (e qualquer coisa depois)" -- `[A, B]` "A na primeira posição AND o B na segunda posição (e qualquer coisa depois)" -- `[[A, B], [A, B]]` "(A OR B) na primeira posição AND (A OR B) na segunda posição (e qualquer coisa depois)" +- `[]` “qualquer coisa” +- `[A]` “A na primeira posição (e qualquer coisa depois)” +- `[null, B]` “qualquer coisa na primeira posição E B na segunda posição (e qualquer coisa depois)” +- `[A, B]` “A na primeira posição E B na segunda posição (e qualquer coisa depois)” +- `[[A, B], [A, B]]` “(A OU B) na primeira posição E (A OU B) na segunda posição (e qualquer coisa depois)” - **Parâmetros** 1. `Object` - As opções de filtro: -- `fromBlock`: `QUANTITY|TAG` - (Opcional, padrão: `"latest"`) Número de bloco inteiro ou `"latest"` para o último bloco minerado ou `"pending"`, `"earliest"` para transações ainda não mineradas. -- `toBlock`: `QUANTITY|TAG` - (Opcional, padrão: `"latest"`) Número do bloco inteiro ou `"latest"` para o último bloco minerado ou `"pending"`, `"earliest"` para transações ainda não mineradas. -- `address`: `DATA|Array`, 20 Bytes - (Opcional) Endereço do contrato ou uma lista de endereços dos quais os logs devem se originar. -- `topics`: `Array of DATA`, - (Opcional) Matriz de tópicos de `DATA` de 32 Bytes. Os tópicos são dependentes da ordem. Cada tópico também pode ser um matriz de DADOS (array of DATA) com opções "or". +- `fromBlock`: `QUANTITY|TAG` — (opcional, padrão: `"latest"`) Número de bloco inteiro ou `"latest"` para o último bloco minerado ou `"pending"`, `"earliest"` para as transações ainda não mineradas. +- `toBlock`: `QUANTITY|TAG` — (opcional, padrão: `"latest"`) Número do bloco inteiro ou `"latest"` para o último bloco minerado ou `"pending"`, `"earliest"` para as transações ainda não mineradas. +- `address`: `DATA|Array`, 20 Bytes — (opcional) Endereço do contrato ou uma lista de endereços dos quais os logs devem ser provenientes. +- `topics`: `Array of DATA`, — (opcional) Matriz de tópicos de `DATA` de 32 Bytes. Os tópicos são dependentes da ordem. Cada tópico também pode ser uma matriz de DADOS (array of DATA) com opções “ou”. ```js params: [ @@ -1478,7 +1507,7 @@ params: [ ] ``` -**Retorna** `QUANTITY` - Uma id de filtro. +**Retorna** `QUANTITY` — Uma ID de filtro. **Exemplo** @@ -1495,11 +1524,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topic ### eth_newBlockFilter {#eth_newblockfilter} -Cria um filtro no nó, para notificar quando um novo bloco chegar. Para verificar se o estado mudou, chame [eth_getFilterChanges](#eth_getfilterchanges). +Cria um filtro no nó para notificar quando um novo bloco chega. Para verificar se o estado mudou, chame [eth_getFilterChanges](#eth_getfilterchanges). **Parâmetros** Nenhum -**Retorna** `QUANTITY` - Um id de filtro. +**Retorna** `QUANTITY` — Uma ID de filtro. **Exemplo** @@ -1516,11 +1545,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newBlockFilter","params":[], ### eth_newPendingTransactionFilter {#eth_newpendingtransactionfilter} -Cria um filtro no nó, para notificar quando chegar novas transações pendentes. Para verificar se o estado mudou, chame [eth_getFilterChanges](#eth_getfilterchanges). +Cria um filtro no nó para notificar quando chegam novas transações pendentes. Para verificar se o estado mudou, chame [eth_getFilterChanges](#eth_getfilterchanges). **Parâmetros** Nenhum -**Retorna** `QUANTITY` - Um id de filtro. +**Retorna** `QUANTITY` — Uma ID de filtro. **Exemplo** @@ -1537,7 +1566,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter" ### eth_uninstallFilter {#eth_uninstallfilter} -Desinstala um filtro com a id fornecida. Deve ser sempre chamado quando o relógio não for mais necessário. Além disso, filtra o tempo limite quando não são solicitados com [eth_getFilterChanges](#eth_getfilterchanges) por um período de tempo. +Desinstala um filtro com a ID fornecida. Deve ser sempre chamado quando o relógio não for mais necessário. Além disso, filtra o tempo limite quando não são solicitados com [eth_getFilterChanges](#eth_getfilterchanges) por um período de tempo. **Parâmetros** @@ -1549,7 +1578,7 @@ params: [ ] ``` -**Retorna** `Boolean` - `true` se o filtro foi desinstalado com sucesso, caso contrário `false`. +**Retorna** `Boolean` — `true` se o filtro foi desinstalado com sucesso, caso contrário `false`. **Exemplo** @@ -1566,7 +1595,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_uninstallFilter","params":[" ### eth_getFilterChanges {#eth_getfilterchanges} -Método de sondagem para um filtro, o qual retorna uma matriz de logs que ocorreram desde a última sondagem. +Método de sondagem para um filtro, que retorna uma matriz de logs que ocorreram desde a última sondagem. **Parâmetros** @@ -1578,20 +1607,20 @@ params: [ ] ``` -**Retorna** `Array` - Matriz de log de objetos ou uma matriz vazia se nada mudou desde a última pesquisa. - -- Para filtros criados com `eth_newBlockFilter` o retorno são hashes de bloco (`DATA`, 32 Bytes), ex. `["0x3454645634534..."]`. -- Para filtros criados com `eth_newPendingTransactionFilter` o retorno são hashes de transação (`DATA`, 32 Bytes), ex. `["0x6345343454645..."]`. -- Para filtros criados com logs `eth_newFilter` são objetos com os seguintes parâmetros: - - `removed`: `TAG` - `true` quando o log foi removido, devido a uma reorganização da cadeia. `false` se for um log válido. - - `logIndex`: `QUANTITY` - Inteiro da posição do índice de log no bloco. `null` quando seu log pendente. - - `transactionIndex`: `QUANTITY` - Inteiro da posição do índice de transações foi criado no log. `null` quando seu log pendente. - - `transactionHash`: `DATA`, 32 Bytes - Hash das transações das quais este log foi criado. `null` quando seu log pendente. - - `blockHash`: `DATA`, 32 Bytes - Hash do bloco onde este log estava. `null` quando estiver pendente. `null` quando seu log pendente. - - `blockNumber`: `QUANTITY` - O número do bloco onde este log estava. `null` quando está pendente. `null` quando seu log pendente. - - `endereço`: `DADOS`, 20 Bytes - Endereço de origem deste log. - - `data`: `DATA` - Contém um ou mais argumentos não indexados de 32 Bytes do log. - - `topics`: `Array of DATA` - Matriz de 0 a 4 32 Bytes `DATA` de argumentos de log indexados. (Em _solidity_: O primeiro tópico é o _hash_ da assinatura do evento (por exemplo, ` Deposit(address,bytes32,uint256)`), exceto que você declarou o evento com o especificador `anonymous`.) +**Retorna** `Array` — Matriz de objetos de log ou uma matriz vazia se nada mudou desde a última sondagem. + +- Para filtros criados com `eth_newBlockFilter`, o retorno são hashes de bloco (`DATA`, 32 Bytes), por exemplo, `["0x3454645634534..."]`. +- Para filtros criados com `eth_newPendingTransactionFilter`, o retorno são hashes de transação (`DATA`, 32 Bytes), por exemplo, `["0x6345343454645..."]`. +- Para filtros criados com `eth_newFilter`, os logs são objetos com os seguintes parâmetros: + - `removed`: `TAG` — `true` quando o log foi removido devido a uma reorganização da cadeia. `false` se for um log válido. + - `logIndex`: `QUANTITY` — Inteiro da posição do índice de log no bloco. `null` quando o log estiver pendente. + - `transactionIndex`: `QUANTITY` — Inteiro a partir do qual o log de posição do índice foi criado. `null` quando o log estiver pendente. + - `transactionHash`: `DATA`, 32 Bytes — Hash das transações a partir das quais este log foi criado. `null` quando o log estiver pendente. + - `blockHash`: `DATA`, 32 Bytes — Hash do bloco onde este log estava localizado. `null` quando está pendente. `null` quando o log estiver pendente. + - `blockNumber`: `QUANTITY` — O número do bloco onde este log estava localizado. `null` quando está pendente. `null` quando o log estiver pendente. + - `endereço`: `DADOS`, 20 Bytes — Endereço de origem deste log. + - `data`: `DATA` — Contém um ou mais argumentos não indexados de 32 Bytes do log. + - `topics`: `Array of DATA` — Matriz de 0 a 4 32 Bytes `DATA` de argumentos de log indexados. (No _Solidity_: O primeiro tópico é o _hash_ da assinatura do evento (por exemplo, ` Deposit(address,bytes32,uint256)`), exceto se você declarou o evento com o especificador `anonymous`.) - **Exemplo** ```js @@ -1618,7 +1647,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":[ ### eth_getFilterLogs {#eth_getfilterlogs} -Retorna uma matriz de todos os logs correspondentes ao filtro com a Id fornecida. +Retorna uma matriz de todos os logs correspondentes ao filtro com a ID fornecida. **Parâmetros** @@ -1643,17 +1672,17 @@ Resultado veja [eth_getFilterChanges](#eth_getfilterchanges) ### eth_getLogs {#eth_getlogs} -Retorna uma matriz de todos os logs que correspondem a determinado objeto de filtro. +Retorna uma matriz de todos os logs que correspondem a um determinado objeto de filtro. **Parâmetros** 1. `Object` - As opções de filtro: -- `fromBlock`: `QUANTITY|TAG` - (opcional, padrão: `"latest"`) Número do bloco inteiro ou `"latest" para o último bloco minerado ou "pending"`, `"earliest"` para transações ainda não mineradas. -- `toBlock`: `QUANTITY|TAG` - (opcional, padrão: `"latest"`) Número de bloco inteiro ou `"latest" para o último bloco minerado ou "pending"`, `"earliest"` para transações ainda não mineradas. -- `endereço`: `DATA|Array`, 20 Bytes - (opcional) Endereço do contrato ou uma lista de endereços dos quais os logs devem se originar. -- `topics`: `Array of DATA`, - (opcional) Array de tópicos de `DATA` de 32 Bytes. Os tópicos são dependentes da ordem. Cada tópico também pode ser uma matriz de DADOS com opções "ou". -- `blockhash`: `DATA`, 32 Bytes - (opcional, **futuro**) Com a adição de EIP-234, `blockHash` ser uma nova opção de filtro que restringe os logs retornados ao bloco único com o hash de 32 bytes `blockHash`. Usar `blockHash` é equivalente a `fromBlock` = `toBlock` = o número do bloco com hash `blockHash`. Se `blockHash` estiver presente nos critérios de filtro, nem `fromBlock` nem `toBlock` serão permitidos. +- `fromBlock`: `QUANTITY|TAG` — (opcional, padrão: `"latest"`) Número de bloco inteiro ou `"latest"` para o último bloco minerado ou `"pending"`, `"earliest"` para as transações ainda não mineradas. +- `toBlock`: `QUANTITY|TAG` — (opcional, padrão: `"latest"`) Número do bloco inteiro ou `"latest"` para o último bloco minerado ou `"pending"`, `"earliest"` para as transações ainda não mineradas. +- `address`: `DATA|Array`, 20 Bytes — (opcional) Endereço do contrato ou uma lista de endereços dos quais os logs devem ser provenientes. +- `topics`: `Array of DATA`, — (opcional) Matriz de tópicos de `DATA` de 32 Bytes. Os tópicos são dependentes da ordem. Cada tópico também pode ser uma matriz de DADOS (array of DATA) com opções “ou”. +- `blockhash`: `DATA`, 32 Bytes — (opcional, **futuro**) Com a adição do EIP-234, `blockHash` será uma nova opção de filtro, que restringe os logs retornados ao bloco único com o hash de 32 bytes `blockHash`. Usar `blockHash` é equivalente a `fromBlock` = `toBlock` = o número do bloco com hash `blockHash`. Se `blockHash` estiver presente nos critérios de filtro, nem `fromBlock`, nem `toBlock` serão permitidos. ```js params: [ @@ -1678,11 +1707,11 @@ Resultado veja [eth_getFilterChanges](#eth_getfilterchanges) ### eth_getWork {#eth_getwork} -Retorna o hash do bloco atual, o seedHash e a condição de limite a ser atendida ("destino"). +Retorna o hash do bloco atual, o seedHash e a condição de limite a ser atendida (“alvo”). **Parâmetros** Nenhum -**Retorna** `Array` - Matriz com as seguintes propriedades: +**Retorna** `Array` — Matriz com as seguintes propriedades: 1. `DATA`, 32 Bytes - Cabeçalho do bloco atual pow-hash 2. `DATA`, 32 Bytes - O hash da semente usada para o DAG. @@ -1723,7 +1752,7 @@ params: [ ] ``` -**Retorna** `Boolean` - retorna `true` se a solução fornecida for válida, caso contrário, `false`. +**Retorna** `Boolean` — retorna `true` se a solução fornecida for válida, caso contrário, `false`. **Exemplo** @@ -1754,7 +1783,7 @@ params: [ ] ``` -**Retorna** `Boolean` - retorna `true` se o envio foi realizado com sucesso e `false` caso contrário. +**Retorna** `Boolean` — Retorna `true` se o envio foi realizado com sucesso e, caso contrário, `false`. **Exemplo** @@ -1771,9 +1800,9 @@ curl -X POST --data '{"jsonrpc":"2.0", "method":"eth_submitHashrate", "params":[ ### db_putString (deprecated) {#db_putstring} -Armazena uma string no banco de dados local. +Armazena uma cadeia de caracteres no banco de dados local. -**Observação:** Essa função está obsoleta. +**Observação:** Essa função foi preterida. **Parâmetros** @@ -1785,7 +1814,7 @@ Armazena uma string no banco de dados local. params: ["testDB", "myKey", "myString"] ``` -**Retorna** `Boolean` - retorna `true` se o valor foi armazenado, do contrário `false`. +**Retorna** `Boolean` — Retorna `true` se o valor foi armazenado, caso contrário `false`. **Exemplo** @@ -1802,7 +1831,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"db_putString","params":["testDB" ### db_getString (deprecated) {#db_getstring} -Retorna a string do banco de dados local. **Observação:** Essa função está depreciada. +Retorna a cadeia de caracteres do banco de dados local. **Observação:** Essa função foi preterida. **Parâmetros** @@ -1813,7 +1842,7 @@ Retorna a string do banco de dados local. **Observação:** Essa função está params: ["testDB", "myKey"] ``` -**Retorna** `String` - A string armazenada anteriormente. +**Retorna** `String` — A cadeia de caracteres armazenada anteriormente. **Exemplo** @@ -1830,7 +1859,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"db_getString","params":["testDB" ### db_putHex (deprecated) {#db_puthex} -Armazena dados binários no banco de dados local. **Observação:** Essa função está depreciada. +Armazena dados binários no banco de dados local. **Observação:** Essa função foi preterida. **Parâmetros** @@ -1842,7 +1871,7 @@ Armazena dados binários no banco de dados local. **Observação:** Essa funçã params: ["testDB", "myKey", "0x68656c6c6f20776f726c64"] ``` -**Retorna** `Boolean` - retorna `true` se o valor foi armazenado, caso contrário `false`. +**Retorna** `Boolean` — Retorna `true` se o valor foi armazenado, caso contrário `false`. **Exemplo** @@ -1859,7 +1888,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"db_putHex","params":["testDB","m ### db_getHex (deprecated) {#db_gethex} -Armazena dados binários no banco de dados local. **Observação:** Essa função está depreciada. +Armazena dados binários do banco de dados local. **Observação:** Essa função foi preterida. **Parâmetros** @@ -1870,7 +1899,7 @@ Armazena dados binários no banco de dados local. **Observação:** Essa funçã params: ["testDB", "myKey"] ``` -**Retorna** `DADOS` - Os dados previamente armazenados. +**Retorna** `DATA` — Os dados previamente armazenados. **Exemplo** @@ -1889,11 +1918,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"db_getHex","params":["testDB","m Retorna a versão atual do protocolo Whisper. -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** Nenhum -**Retorna** `String` - A versão atual do protocolo Whisper +**Retorna** `String` — A versão atual do protocolo Whisper **Exemplo** @@ -1912,18 +1941,18 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_version","params":[],"id":67 Envia uma mensagem do Whisper. -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** 1. `Objeto` - O objeto de postagem do Whisper: -- `de`: `DADOS`, 60 Bytes - (opcional) A identidade do remetente. -- `para`: `DATA`, 60 Bytes - (opcional) Identidade do destinatário. Quando presente, o Whisper criptografará a mensagem para que apenas o destinatário possa descriptografá-la. -- `tópicos`: `Matriz de DADOS` - Matriz de `DADOS` tópicos, para o receptor identificar as mensagens. -- `carga`: `DADOS` - A carga da mensagem. -- `prioridade`: `QUANTITY` - O inteiro da prioridade em um rang de... (?). -- `ttl`: `QUANTITY` - Inteiro do tempo para viver em segundos. +- `de`: `DATA`, 60 Bytes — (opcional) A identidade do remetente. +- `para`: `DATA`, 60 Bytes — (opcional) A identidade do destinatário. Quando presente, o Whisper criptografará a mensagem para que apenas o destinatário possa descriptografá-la. +- `tópicos`: `Array of DATA` — Matriz de tópicos de `DATA` para o destinatário identificar as mensagens. +- `carga`: `DATA` — O conteúdo da mensagem. +- `prioridade`: `QUANTITY` — O inteiro da prioridade em um intervalo de... (?). +- `ttl`: `QUANTITY` — Inteiro do tempo residual em segundos. ```js params: [ @@ -1941,7 +1970,7 @@ params: [ ] ``` -**Retorna** `Boolean` - retorna `true` se a mensagem foi enviada, caso contrário `false`. +**Retorna** `Boolean` — Retorna `true` se a mensagem foi enviada, caso contrário `false`. **Exemplo** @@ -1960,11 +1989,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_post","params":[{"from":"0xc Cria uma nova identidade Whisper no cliente. -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** Nenhum -**Retorna** `DATA`, 60 Bytes - o endereço da nova identidade. +**Retorna** `DATA`, 60 Bytes — O endereço da nova identidade. **Exemplo** @@ -1981,9 +2010,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newIdentity","params":[],"id ### shh_hasIdentity (deprecated){#shh_hasidentity} -Verifica se o cliente mantém as chaves privadas de determinada identidade. +Verifica se o cliente mantém as chaves privadas de uma determinada identidade. -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** @@ -1995,7 +2024,7 @@ params: [ ] ``` -**Retorna** `Boolean` - retorna `true` se o cliente possui a chave privada para essa identidade, caso contrário `falso`. +**Retorna** `Boolean` — Retorna `true` se o cliente possui a chave privada para essa identidade, caso contrário `false`. **Exemplo** @@ -2012,11 +2041,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_hasIdentity","params":["0x04 ### shh_newGroup (deprecated){#shh_newgroup} -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** Nenhum -**Retorna** `DATA`, 60 Bytes - O endereço do novo grupo. (?) +**Retorna** `DATA`, 60 Bytes — O endereço do novo grupo. (?) **Exemplo** @@ -2033,7 +2062,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newGroup","params":[],"id":7 ### shh_addToGroup (deprecated){#shh_addtogroup} -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** @@ -2045,7 +2074,7 @@ params: [ ] ``` -**Retorna** `Boolean` - `true` se o filtro foi desinstalado com sucesso, caso contrário `false` (?). +**Retorna** `Boolean` — Retorna `true` se a identidade foi adicionada com sucesso ao grupo, caso contrário `false` (?). **Exemplo** @@ -2062,14 +2091,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_addToGroup","params":["0x04f ### shh_newFilter (deprecated){#shh_newfilter} -Cria um filtro para notificar, quando o cliente recebe a mensagem do Whisper que corresponde às opções do filtro. **Observação:** Essa função está depreciada. +Cria um filtro para notificar quando o cliente recebe a mensagem do Whisper que corresponde às opções do filtro. **Observação:** Essa função foi preterida. **Parâmetros** 1. `Object` - As opções de filtro: -- `to`: `DATA`, 60 Bytes - (opcional) Identidade do destinatário. _Quando apresentado, ele tentará descriptografar qualquer mensagem recebida se o cliente possuir a chave privada dessa identidade._ -- `tópicos`: `Array of DATA` - Matriz de `DADOS` tópicos aos quais, os tópicos da mensagem recebida devem corresponder. You can use the following combinations: +- `to`: `DATA`, 60 Bytes — (opcional) Identidade do destinatário. _Quando apresentado, ele tentará descriptografar qualquer mensagem recebida se o cliente possuir a chave privada dessa identidade._ +- `tópicos`: `Array of DATA` — Matriz de tópicos de `DATA` que devem corresponder aos tópicos das mensagens recebidas. Você pode usar as seguintes combinações: - `[A, B] = A && B` - `[A, [B, C]] = A && (B || C)` - `[null, A, B] = ANYTHING && A && B` `null` funciona como um curinga @@ -2084,7 +2113,7 @@ params: [ ] ``` -**Retorno** `QUANTITY` - O filtro recém-criado. +**Retorna** `QUANTITY` — O filtro recém-criado. **Exemplo** @@ -2101,7 +2130,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newFilter","params":[{"topic ### shh_uninstallFilter (deprecated){#shh_uninstallfilter} -Desinstala um filtro com o id fornecido. Deve ser sempre chamado quando o relógio não for mais necessário. Adicionalmente, filtra o tempo limite quando não são solicitados com [shh_getFilterChanges](#shh_getfilterchanges) por um período. **Observação:** Essa função está depreciada. +Desinstala um filtro com a ID fornecida. Deve ser sempre chamado quando o relógio não for mais necessário. Adicionalmente, filtra o tempo limite quando não são solicitados com [shh_getFilterChanges](#shh_getfilterchanges) por um determinado período. **Observação:** Essa função foi preterida. **Parâmetros** @@ -2113,7 +2142,7 @@ params: [ ] ``` -**Retorna** `Boolean` - `true` se o filtro foi desinstalado com sucesso, caso contrário `false`. +**Retorna** `Boolean` — `true` se o filtro foi desinstalado com sucesso, caso contrário `false`. **Exemplo** @@ -2130,7 +2159,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_uninstallFilter","params":[" ### shh_getFilterChanges (deprecated){#shh_getfilterchanges} -Método de sondagem para filtros do Whisper. Retorna novas mensagens desde a última chamada deste método. **Nota:** chamar o método [shh_getMessages](#shh_getmessages) redefinirá o buffer desse método, para que você não receba mensagens duplicadas. **Observação:** Essa função está depreciada. +Método de sondagem para filtros do Whisper. Retorna novas mensagens desde a última chamada desse método. **Observação:** chamar o método [shh_getMessages](#shh_getmessages) redefinirá o buffer desse método para que você não receba mensagens duplicadas. **Observação:** Essa função foi preterida. **Parâmetros** @@ -2142,17 +2171,17 @@ params: [ ] ``` -**Retorno** `Matriz` - Matriz de mensagens recebidas desde a última pesquisa: +**Retorna** `Array` — Matriz de mensagens recebidas desde a última sondagem: -- `hash`: `DATA`, 32 Bytes (?) - O hash da mensagem. -- `from`: `DATA`, 60 Bytes - O remetente da mensagem, se um remetente foi especificado. -- `to`: `DATA`, 60 Bytes - O destinatário da mensagem, se um destinatário foi especificado. -- `expiry`: `QUANTITY` - Inteiro de tempo em segundos quando esta mensagem deve expirar (?). -- `ttl`: `QUANTITY` - Inteiro do tempo que a mensagem deve flutuar no sistema em segundos (?). -- `sent`: `QUANTITY` - Inteiro do timestamp unix quando a mensagem foi enviada. -- `tópicos`: `Array of DATA` - Matriz de `DADOS` tópicos que a mensagem contida. -- `carga`: `DADOS` - A carga da mensagem. -- `workProved`: `QUANTITY` - Inteiro da obra que esta mensagem é necessária antes de ser enviada (?). +- `hash`: `DATA`, 32 Bytes (?) — O hash da mensagem. +- `from`: `DATA`, 60 Bytes — O remetente da mensagem, se um remetente foi especificado. +- `to`: `DATA`, 60 Bytes — O destinatário da mensagem, se um destinatário foi especificado. +- `expiry`: `QUANTITY` — Inteiro do tempo em segundos quando esta mensagem deve expirar (?). +- `ttl`: `QUANTITY` — Inteiro do tempo que a mensagem deve flutuar no sistema em segundos (?). +- `sent`: `QUANTITY` — Inteiro do carimbo de data/hora unix quando a mensagem foi enviada. +- `tópicos`: `Array of DATA` — Matriz de tópicos de `DATA` contidos na mensagem. +- `carga`: `DATA` — O conteúdo da mensagem. +- `workProved`: `QUANTITY` — Inteiro do trabalho que esta mensagem exigiu antes de ser enviada (?). **Exemplo** @@ -2179,9 +2208,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_getFilterChanges","params":[ ### shh_getMessages (deprecated) {#shh_getmessages} -Tenha todas as mensagens que correspondem a um filtro. Ao contrário do `shh_getFilterChanges` isso retorna todas as mensagens. +Obtenha todas as mensagens correspondentes a um filtro. Ao contrário de `shh_getFilterChanges`, isso retorna todas as mensagens. -**Observação:** Essa função está depreciada. +**Observação:** Essa função foi preterida. **Parâmetros** @@ -2193,7 +2222,7 @@ params: [ ] ``` -**Retornos** Veja [shh_getFilterChanges](#shh_getfilterchanges) +**Retorna** Consulte [shh_getFilterChanges](#shh_getfilterchanges) **Exemplo** @@ -2203,15 +2232,15 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_getMessages","params":["0x7" ],"id":73}' ``` -Veja o resultado [shh_getFilterChanges](#shh_getfilterchanges) +Consulte o resultado [shh_getFilterChanges](#shh_getfilterchanges) -## Exemplos de uso {#usage-example} +## Exemplo de utilização {#usage-example} ### Implementando um contrato usando JSON_RPC {#deploying-contract} -Esta seção inclui uma demonstração de como implantar um contrato usando apenas a interface RPC. Existem rotas alternativas para a implantação de contratos onde essa complexidade é abstraída, por exemplo, usando bibliotecas construídas sobre a interface RPC, como [web3.js](https://web3js.readthedocs.io/) e [web3.py](https://github.com/ethereum/web3.py). Essas abstrações são geralmente mais fáceis de entender e menos propensas a erros, mas ainda é útil entender o que está acontecendo internamente, ou seja, sem que o usuário perceba. +Esta seção inclui uma demonstração de como implantar um contrato usando apenas a interface RPC. Existem rotas alternativas para a implantação de contratos nos quais essa complexidade é abstraída, por exemplo, usando bibliotecas criadas sobre a interface RPC, como [web3.js](https://web3js.readthedocs.io/) e [web3.py](https://github.com/ethereum/web3.py). Essas abstrações são geralmente mais fáceis de entender e menos propensas a erros, mas ainda é útil entender o que está acontecendo internamente, ou seja, sem que o usuário perceba. -Veja a seguir um contrato inteligente simples chamado `Multiply7` que será implantado usando a interface JSON-RPC em um nó Ethereum. Este tutorial pressupõe que o leitor já esteja executando um nó Geth. Mais informações sobre nós e clientes estão disponíveis [aqui](/developers/docs/nodes-and-clients/run-a-node). Consulte a documentação individual do [client](/developers/docs/nodes-and-clients/) para ver como iniciar o HTTP JSON-RPC para clientes não Geth. A maioria dos clientes por padrão atendem em `localhost:8545`. +Veja a seguir um contrato inteligente simples chamado `Multiply7` que será implantado usando a interface JSON-RPC em um nó Ethereum. Este tutorial pressupõe que o leitor já esteja executando um nó Geth. Mais informações sobre nós e clientes estão disponíveis [aqui](/developers/docs/nodes-and-clients/run-a-node). Consulte a documentação específica de cada [cliente](/developers/docs/nodes-and-clients/) para ver como iniciar o JSON-RPC HTTP para clientes não Geth. A maioria dos clientes atende por padrão no `localhost:8545`. ```javascript contract Multiply7 { @@ -2223,7 +2252,7 @@ contract Multiply7 { } ``` -A primeira coisa a fazer é certificar-se de que a interface HTTP RPC esteja habilitada. Isso significa que fornecemos ao Geth o parâmetro `--http` na inicialização. Neste exemplo, usamos o nó Geth em uma cadeia de desenvolvimento privada. Usando essa abordagem, não precisamos de ether na rede real. +A primeira coisa a fazer é verificar se a interface HTTP RPC está habilitada. Isso significa que fornecemos ao Geth o sinalizador `--http` na inicialização. Neste exemplo, usamos o nó Geth em uma cadeia de desenvolvimento privada. Usando essa abordagem, não precisamos de ether na rede real. ```bash geth --http --dev console 2>>geth.log @@ -2231,7 +2260,7 @@ geth --http --dev console 2>>geth.log Isso iniciará a interface HTTP RPC em `http://localhost:8545`. -Podemos verificar se a interface está funcionando recuperando o endereço e o saldo da Coinbase usando [curl](https://curl.se). Por favor, note que os dados nestes exemplos serão diferentes no seu nó local. Se você quiser tentar estes comandos, substitua os parâmetros de solicitação na segunda solicitação do curl pelo resultado retornado da primeira. +Podemos verificar se a interface está funcionando recuperando o endereço e o saldo da Coinbase usando [curl](https://curl.se). Observe que os dados nesses exemplos serão diferentes no seu nó local. Se você quiser tentar esses comandos, substitua os parâmetros de solicitação na segunda solicitação curl pelo resultado retornado da primeira. ```bash curl --data '{"jsonrpc":"2.0","method":"eth_coinbase", "id":1}' -H "Content-Type: application/json" localhost:8545 @@ -2241,16 +2270,16 @@ curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635 {"id":2,"jsonrpc":"2.0","result":"0x1639e49bba16280000"} ``` -Como os números são codificados em hexadecimal, o saldo é retornado em wei como uma string hexadecimal. Se quisermos ter o saldo em ether como um número, podemos usar o web3 do console Geth. +Como os números são codificados em hexa, o saldo é retornado em Wei como uma cadeia de caracteres hexadecimal. Se quisermos ter o saldo em ether como um número, podemos usar a Web3 do console Geth. ```javascript web3.fromWei("0x1639e49bba16280000", "ether") // "410" ``` -Agora que há algum éter em nossa cadeia de desenvolvimento privada, podemos implantar o contrato. O primeiro passo é compilar o contrato Multiply7 para byte code que pode ser enviado para a EVM. Para instalar o solc, o compilador do Solidity, siga a [Solidity documentation](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Talvez você queira usar uma versão `solc` mais antiga para corresponder [à versão do compilador usada para nosso exemplo](https://github.com/ethereum/solidity/releases/tag/v0.4.20).) +Agora que já temos alguns ethers em nossa cadeia de desenvolvimento privada, podemos implantar o contrato. O primeiro passo é compilar o contrato Multiply7 em byte code, que pode ser enviado para a EVM. Para instalar o solc, o compilador do Solidity, confira a [documentação do Solidity](https://docs.soliditylang.org/en/latest/installing-solidity.html). (Você pode usar uma versão do `solc` mais antiga que corresponda [à versão do compilador usada em nosso exemplo](https://github.com/ethereum/solidity/releases/tag/v0.4.20).) -O próximo passo é compilar o contrato Multiply7 para byte code que pode ser enviado para a EVM. +O próximo passo é compilar o contrato Multiply7 em byte code, que pode ser enviado para a EVM. ```bash echo 'pragma solidity ^0.4.16; contract Multiply7 { event Print(uint); function multiply(uint input) public returns (uint) { Print(input * 7); return input * 7; } }' | solc --bin @@ -2260,47 +2289,47 @@ Binary: 6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029 ``` -Agora que temos o código compilado, precisamos determinar quanto gás custa para implantá-lo. A interface RPC tem um método `eth_estimateGas` que nos dará uma estimativa. +Agora que temos o código compilado, precisamos determinar o quanto a sua implantação custará em gás. A interface RPC tem um método `eth_estimateGas`, que nos dará uma estimativa. ```bash curl --data '{"jsonrpc":"2.0","method": "eth_estimateGas", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 5}' -H "Content-Type: application/json" localhost:8545 {"jsonrpc":"2.0","id":5,"result":"0x1c31e"} ``` -E finalmente implantar o contrato. +Finalmente, implante o contrato. ```bash curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "gas": "0x1c31e", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 6}' -H "Content-Type: application/json" localhost:8545 {"id":6,"jsonrpc":"2.0","result":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"} ``` -A transação é aceita pelo nó e um hash de transação é retornado. Esse hash pode ser usado para rastrear a transação. O próximo passo é determinar o endereço onde nosso contrato está implantado. Cada transação executada irá criar um recibo. Este recibo contém várias informações sobre a transação, como em qual bloco a transação foi incluída e quanto gás foi usado pela EVM. Se uma transação criar um contrato, ela também vai conter o endereço do contrato. Podemos recuperar o recibo com o método RPC `eth_getTransactionReceipt`. +A transação é aceita pelo nó e um hash de transação é retornado. Esse hash pode ser usado para rastrear a transação. O próximo passo é determinar o endereço onde nosso contrato está implantado. Cada transação executada criará uma confirmação de recebimento. Essa confirmação de recebimento contém várias informações sobre a transação, como em qual bloco a transação foi incluída e quanto gás foi usado pela EVM. Se uma transação criar um contrato, ela também conterá o endereço do contrato. Podemos recuperar a confirmação de recebimento com o método RPC `eth_getTransactionReceipt`. ```bash curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": ["0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"], "id": 7}' -H "Content-Type: application/json" localhost:8545 {"jsonrpc":"2.0","id":7,"result":{"blockHash":"0x77b1a4f6872b9066312de3744f60020cbd8102af68b1f6512a05b7619d527a4f","blockNumber":"0x1","contractAddress":"0x4d03d617d700cf81935d7f797f4e2ae719648262","cumulativeGasUsed":"0x1c31e","from":"0x9b1d35635cc34752ca54713bb99d38614f63c955","gasUsed":"0x1c31e","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","status":"0x1","to":null,"transactionHash":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf","transactionIndex":"0x0"}} ``` -Nosso contrato foi criado em `0x4d03d617d700cf81935d7f797f4e2ae719648262`. Um resultado nulo em vez de um recibo significa que a transação não foi incluída em um bloco ainda. Aguarde um momento e verifique se o seu minerador está em execução e tente novamente. +Nosso contrato foi criado em `0x4d03d617d700cf81935d7f797f4e2ae719648262`. Um resultado nulo em vez de um recibo significa que a transação ainda não foi incluída em um bloco. Aguarde um momento, verifique se o seu minerador está em execução e tente novamente. #### Interagindo com contratos inteligentes {#interacting-with-smart-contract} Neste exemplo, enviaremos uma transação usando `eth_sendTransaction` para o método `multiply` do contrato. -`eth_sendTransaction` requer vários argumentos, especificamente `from`, `to` e `data`. `From` é o endereço público de nossa conta e `to` é o endereço do contrato. O argumento `data` contém um payload (dados) que define qual método deve ser chamado e com quais argumentos. É aqui que o [ABI (application binary interface ou interface binária do aplicativo)](https://docs.soliditylang.org/en/latest/abi-spec.html) entra em ação. A ABI é um arquivo JSON que estabelece como definir e codificar dados para a EVM. +`eth_sendTransaction` requer vários argumentos, especificamente `from`, `to` e `data`. `From` é o endereço público de nossa conta, e `to` é o endereço do contrato. O argumento `data` contém um conteúdo que define qual método deve ser chamado e com quais argumentos. É aqui que a [ABI (application binary interface ou interface binária do aplicativo)](https://docs.soliditylang.org/en/latest/abi-spec.html) entra em ação. A ABI é um arquivo JSON que estabelece como definir e codificar dados para a EVM. -Os bytes do payload definem qual método no contrato é chamado. Estes são os primeiros 4 bytes do hash Keccak sobre o nome da função e seus tipos de argumento, codificado em hexadecimal. A função multiplicar aceita um uint que é um alias para uint256. Isso nos deixa com: +Os bytes do conteúdo definem qual método no contrato é chamado. Esses são os primeiros 4 bytes do hash Keccak sobre o nome da função e seus tipos de argumento, com codificação hexadecimal. A função multiplicar aceita um uint, que é um alias de uint256. Isso nos deixa com: ```javascript web3.sha3("multiply(uint256)").substring(0, 10) // "0xc6888fa1" ``` -O próximo passo é codificar os argumentos. Existe apenas um uint256, digamos, o valor 6. A ABI tem uma seção que especifica como codificar os tipos uint256. +O próximo passo é codificar os argumentos. Existe apenas um uint256, por exemplo, o valor 6. A ABI tem uma seção que especifica como codificar os tipos uint256. -`int: enc(X)` é a codificação em complemento de dois big-endian de X, preenchida no lado de ordem superior (esquerda) com 0xff para X negativo e com zero > bytes para X positivo tal que o comprimento seja um múltiplo de 32 bytes. +`int: enc(X)` é a codificação Big Endian do complemento de dois de X, preenchida no lado superior (esquerdo) com 0xff para X negativo e com zero > bytes para X positivo, de modo que o tamanho seja um múltiplo de 32 bytes. -Isso codifica para `0000000000000000000000000000000000000000000000000000000000000006`. +Isso codifica em `0000000000000000000000000000000000000000000000000000000000000006`. Combinando o seletor de função e o argumento codificado, nossos dados serão `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`. @@ -2311,7 +2340,7 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from {"id":8,"jsonrpc":"2.0","result":"0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74"} ``` -Desde que uma transação foi enviada, um hash de transação foi retornado. A recuperação do recibo fornece: +Como uma transação foi enviada, um hash de transação foi retornado. A recuperação do recibo: ```javascript { @@ -2335,7 +2364,7 @@ Desde que uma transação foi enviada, um hash de transação foi retornado. A r } ``` -O recibo contém um log. Este log foi gerado pela EVM na execução da transação e incluído no recibo. A função `multiply` mostra que o evento `Print` foi gerado com a entrada vezes 7. Como o argumento para o evento `Print` era um uint256, podemos decodificá-lo de acordo com as regras da ABI, o que nos deixará com o decimal esperado 42. Além dos dados, vale ressaltar que os tópicos podem ser usados para determinar qual evento criou o log: +O recibo contém um log. Esse log foi gerado pela EVM na execução da transação e incluído no recibo. A função `multiply` mostra que o evento `Print` foi gerado com a entrada 7 vezes. Como o argumento do evento `Print` era um uint256, podemos decodificá-lo conforme as regras da ABI, o que nos deixará com a decimal 42 esperada. Além dos dados, vale ressaltar que os tópicos podem ser usados para determinar qual evento criou o log: ```javascript web3.sha3("Print(uint256)") @@ -2346,8 +2375,8 @@ Esta foi apenas uma breve introdução a algumas das tarefas mais comuns, demons ## Tópicos relacionados {#related-topics} -- [Especificação JSON-RPC](http://www.jsonrpc.org/specification) -- [Nós e clientes](/developers/docs/nodes-and-clients/) +- [Especificações do JSON-RPC](http://www.jsonrpc.org/specification) +- [ Nós e clientes](/developers/docs/nodes-and-clients/) - [APIs JavaScript](/developers/docs/apis/javascript/) - [APIs de Backend](/developers/docs/apis/backend/) - [Clientes de execução](/developers/docs/nodes-and-clients/#execution-clients) diff --git a/src/content/translations/pt-br/developers/docs/blocks/tx-block.png b/src/content/translations/pt-br/developers/docs/blocks/tx-block.png new file mode 100644 index 00000000000..c60806b16bf Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/blocks/tx-block.png differ diff --git a/src/content/translations/pt-br/developers/docs/data-and-analytics/block-explorers/index.md b/src/content/translations/pt-br/developers/docs/data-and-analytics/block-explorers/index.md index 296572a036e..ddf69dd3028 100644 --- a/src/content/translations/pt-br/developers/docs/data-and-analytics/block-explorers/index.md +++ b/src/content/translations/pt-br/developers/docs/data-and-analytics/block-explorers/index.md @@ -21,6 +21,8 @@ Você deve entender os conceitos básicos do Ethereum; para que você possa ente - [Ethplorer](https://ethplorer.io/) -_ Também disponível em chinês, espanhol, francês, turco, russo, coreano e vietnamita_ - [OKLink](https://www.oklink.com/eth) - [Otterscan](https://otterscan.io/) +- [Sirato](https://www.web3labs.com/sirato) +- [EthVM](https://www.ethvm.com/) ## Dados {#data} diff --git a/src/content/translations/pt-br/developers/docs/data-availability/index.md b/src/content/translations/pt-br/developers/docs/data-availability/index.md index 4cd4a9cdc77..c6263c592d9 100644 --- a/src/content/translations/pt-br/developers/docs/data-availability/index.md +++ b/src/content/translations/pt-br/developers/docs/data-availability/index.md @@ -4,164 +4,80 @@ description: Uma visão geral dos problemas e soluções relacionados à disponi lang: pt-br --- -A falta de confiança é uma premissa importante das blockchains públicas ("não confie, verifique"). Uma das maneiras pelas quais o Ethereum reduz as suposições de confiança é aplicando regras sobre a disponibilidade de dados. Os produtores de blocos são obrigados a publicar os dados para cada bloco, cujos nós participantes do consenso do Ethereum armazenam localmente. +“Não confie, verifique” é uma máxima comum no Ethereum. A ideia é que seu nó possa verificar de modo independente se a informação que recebe está correta, executando todas as transações nos blocos que recebem dos pares, a fim de garantir que as mudanças propostas correspondam precisamente àquelas calculadas de forma independente pelo nó. Isso significa que os nós não precisam confiar na honestidade dos remetentes do bloco. Isso não é possível se estiverem faltando dados. -Todos os nós da rede Ethereum executam as transações em blocos que recebem dos pares para garantir que as mudanças propostas por um produtor de bloco correspondam com precisão àquelas computadas independentemente pelo nó. É assim que os nós verificam que as novas informações são válidas, ao invés de ter que confiar que os produtores de blocos são honestos. Isso não é possível se algum dado estiver faltando. - -A disponibilidade de dados é importante porque se não pudemos reproduzir algo com os dados que temos disponíveis, do ponto de vista da blockchain, isso não existe. O acesso aos dados do bloco permite que os nós de validação reproduzam transações sem confiança, usando sua versão do estado geral do Ethereum e verifiquem independentemente a exatidão de cada bloco. +**Disponibilidade de dados** se refere à confiança que um usuário pode ter de que os dados necessários para verificar um bloco estão realmente disponíveis para todos os participantes da rede. Para nós completos na camada 1 do Ethereum, isso é relativamente simples; o nó completo baixa uma cópia de todos os dados em cada bloco — os dados _devem_ estar disponíveis para que o download seja possível. Um bloco com dados faltando seria descartado em vez de ser adicionado à blockchain. Isso é “disponibilidade de dados on-chain” e é um recurso de blockchains monolíticas. Os nós completos não podem ser enganados em aceitar transações inválidas porque eles baixam e executam todas as transações para si mesmos. No entanto, para blockchains modulares, rollups de camada 2 e clientes leves, o cenário de disponibilidade de dados é mais complexo, exigindo alguns procedimentos de verificação mais sofisticados. ## Pré-requisitos {#prerequisites} Você deve ter uma boa compreensão dos [fundamentos da blockchain](/developers/docs/intro-to-ethereum/), especialmente sobre [mecanismos de consenso](/developers/docs/consensus-mechanisms/). Esta página também pressupõe que o leitor esteja familiarizado com [blocos](/developers/docs/blocks/), [transações](/developers/docs/transactions/), [nós](/developers/docs/nodes-and-clients/), [soluções de dimensionamento](/developers/docs/scaling/) e outros tópicos relevantes. -## O que é a disponibilidade de dados? {#what-is-data-availability} - -A disponibilidade de dados é a garantia de que o proponente do bloco publicou todos os dados de transação de um bloco e que os dados de transação estão disponíveis para outros participantes da rede. Transações Ethereum são processadas em [blocos](/developers/docs/blocks/). Esses blocos são encadeados juntos para formar a "blockchain". - -Cada bloco tem duas partes principais: - -- O **cabeçalho do bloco**: contém informações gerais (metadados) sobre o bloco, como timestamp, hash do bloco, número do bloco etc. -- O **corpo do bloco**: contém as transações reais processadas como parte do bloco. - -Ao propor novos blocos, os produtores de blocos devem publicar todo o bloco, incluindo os dados da transação (contidos no corpo do bloco). Nós que participam no consenso podem então baixar os dados do bloco e reexecutar as transações para confirmar a sua validade. Sem nós verificando as transações, proponentes de blocos poderiam inserir transações maliciosas em blocos. - -### O problema da disponibilidade de dados {#the-data-availability-problem} - -Podemos resumir o problema da disponibilidade de dados na pergunta: "Como verificamos se os dados de um bloco recém-produzido estão disponíveis?". Esses dados disponíveis são cruciais, pois a segurança do Ethereum pressupõe que nós completos têm acesso aos dados de bloqueio. - -Se um produtor de bloco propõe um bloco sem que todos os dados estejam disponíveis, ele poderia alcançar a finalidade enquanto contém transações inválidas. Mesmo que o bloco seja válido, o fato de os dados do bloco não estarem totalmente disponíveis para validar causa implicações negativas para os usuários e a funcionalidade da rede. - -O problema de disponibilidade de dados também é relevante quando se trata de [soluções de dimensionamento](/developers/docs/scaling/), como rollups. Esses protocolos aumentam a taxa de transferência executando transações fora da rede principal do Ethereum. No entanto, para que eles possam derivar segurança do Ethereum, eles devem publicar dados de transação na rede principal, permitindo que qualquer pessoa verifique a exatidão dos cálculos realizados na cadeia principal. - -#### Disponibilidade de dados e clientes leves - -Embora a noção clássica de disponibilidade de dados tivesse a ver com a visibilidade dos dados das transações para validar nós, pesquisas mais recentes focaram em verificar a disponibilidade de dados com clientes leves. Para clientes leves, o problema da disponibilidade de dados diz respeito à validação da disponibilidade de um bloco sem ter que baixar o bloco inteiro. - -Um cliente leve é um nó Ethereum que se sincroniza apenas com o cabeçalho do bloco mais recente e solicita outras informações de nós completos. Como eles não baixam blocos, clientes leves não podem validar transações ou ajudar a proteger o Ethereum. - -No entanto, o trabalho está em curso para garantir que os clientes leves possam provar a disponibilidade de dados sem a necessidade de baixar blocos. Se os clientes leves puderem verificar a disponibilidade de um bloco, eles poderão contribuir para a segurança do Ethereum, alertando outros nós para a indisponibilidade de um bloco. - -Uma área de pesquisa relacionada é focada em mecanismos para disponibilizar dados prováveis em um Ethereum sem estado. O [conceito de cliente sem estado](https://ethresear.ch/t/the-stateless-client-concept/172) é uma versão proposta do Ethereum, em que a validação de nós não precisa armazenar os dados do estado antes de verificar os blocos. - -Espera-se que a falta de estado melhore a segurança, o dimensionamento e a sustentabilidade a longo prazo do Ethereum. Com requisitos de hardware mais baixos para validação de nós, mais validadores podem participar da rede e protegê-la contra atores maliciosos. - -### Disponibilidade de dados vs. recuperabilidade de dados {#data-availability-vs-data-retrievability} - -Disponibilidade de dados é diferente de recuperabilidade de dados. A disponibilidade de dados é a capacidade dos nós de baixar dados de transações para um bloco enquanto está sendo proposto para adição à cadeia. Em outras palavras, a disponibilidade de dados é relevante quando um bloco ainda está para passar pelo consenso. - -Recuperabilidade de dados é a capacidade de os nós recuperarem _informações históricas_ da blockchain. A história de uma blockchain é composta de blocos antigos e recibos que armazenam informações sobre eventos passados. Embora dados históricos da blockchain possam ser necessários para fins de arquivamento, os nós podem validar a cadeia e processar transações sem eles. - -A preocupação do protocolo principal Ethereum é a disponibilidade de dados, e não a recuperação de dados. O Ethereum não armazenará dados para cada transação que tenha processado para sempre, já que isso aumenta os requisitos de armazenamento para nós completos, impactando negativamente a descentralização do Ethereum. - -Felizmente, a recuperabilidade de dados é um problema muito mais fácil de resolver do que a disponibilidade de dados. A capacidade de recuperar dados históricos da blockchain só precisa de um nó honesto para armazená-lo para que ele seja recuperável. Além disso, algumas entidades, como exploradores de blockchain, têm incentivos para armazenar dados de arquivamento e torná-los disponíveis, sob demanda, para outras pessoas. - -[Mais sobre soluções para o problema de recuperabilidade de dados](https://notes.ethereum.org/@vbuterin/data_sharding_roadmap#Who-would-store-historical-data-under-sharding). - -## Por que a disponibilidade de dados é importante? {#why-is-data-availability-important} - -### Segurança da blockchain {#blockchain-security} +## O problema da disponibilidade de dados {#the-data-availability-problem} -A disponibilidade de dados é crucial para a segurança da blockchain, caso contrário "ataques de retenção de dados" se tornariam muito comuns. Um ataque de retenção de dados ocorre quando um produtor de bloco publica um bloco, mas não compartilha os dados de transação usados para construir o bloco. +O problema da disponibilidade de dados é a necessidade de provar para toda a rede que a forma resumida de alguns dados de transação que estão sendo adicionados à blockchain realmente representa um conjunto de transações válidas, mas fazendo isso sem exigir que todos os nós baixem todos os dados. Os dados completos da transação são necessários para verificar os blocos de forma independente, mas exigir que todos os nós baixem todos os dados da transação é uma barreira para a escalabilidade. As soluções para o problema da disponibilidade de dados visam fornecer garantias suficientes de que os dados completos da transação foram disponibilizados para verificação aos participantes da rede que não baixam e armazenam os dados por conta própria. -Se um ataque de retenção de dados acontecer, nós completos não poderão verificar a exatidão das atualizações em comparação ao estado geral do Ethereum. Isto dá aos proponentes de blocos maliciosos margem para subverter regras de protocolo e antecipar transições de estado inválidas na rede Ethereum. +[Nós leves](/developers/docs/nodes-and-clients/light-clients) e [rollups da camada 2](/developers/docs/scaling) são importantes exemplos de participantes da rede que exigem fortes garantias de disponibilidade de dados, mas não podem baixar e processar dados de transações por conta própria. Evitar baixar dados de transações é o que torna os nós leves e permite que os rollups sejam soluções de escalabilidade eficazes. -A visibilidade dos dados do bloco para nós completos é essencial porque outros participantes da rede, tais como clientes leves, confiam nos nós completos para verificar o estado da rede. Ao contrário de nós completos, os clientes leves apenas verificam os cabeçalhos dos blocos, sem baixar os blocos. Portanto, as regras em torno da disponibilidade de dados garantem que os nós completos possam validar blocos e impedir que a cadeia seja corrompida. +A disponibilidade de dados é também uma preocupação crítica para futuros clientes do Ethereum [“sem estado”](/roadmap/statelessness) que não precisam baixar e armazenar dados de estado para verificar os blocos. Os clientes sem estado ainda precisam ter certeza de que os dados estão disponíveis _em algum lugar_ e que foram processados corretamente. -### Dimensionamento descentralizado {#decentralized-scalability} +## Soluções de disponibilidade de dados {#data-availability-solutions} -[O objetivo do Ethereum é dimensionar a computação sem comprometer a descentralização e segurança](/roadmap/vision/). Devido às restrições da arquitetura monolítica da blockchain, a disponibilidade de dados é fundamental para que o dimensionamento seja descentralizado. +### Amostragem de disponibilidade de dados (DAS) {#data-availability-sampling} -#### Disponibilidade de dados e dimensionamento da camada 2 {#data-availability-and-layer-2-scaling} +Amostragem de Disponibilidade de Dados (DAS, do inglês Data Availability Sampling) é uma forma de a rede verificar se os dados estão disponíveis sem sobrecarregar um nó excessivamente. Cada nó (incluindo os nós que não foram nomeados para o staking) baixa um subconjunto pequeno e selecionado aleatoriamente do total de dados. Baixar com sucesso as amostras confirma com alta confiança que todos os dados estão disponíveis. Isso se baseia na codificação de eliminação de dados, que expande um determinado conjunto de dados com informações redundantes (a maneira como isso é feito é encaixando uma função conhecida como _polinomial_ sobre os dados e avaliando esse polinômio em pontos adicionais). Isso permite que os dados originais sejam recuperados a partir dos dados redundantes quando necessário. Consequentemente, se _qualquer_ dado original estiver indisponível, a criação dos dados causaria a perda de _metade_ dos dados expandidos! A quantidade de amostras de dados baixadas por cada nó pode ser ajustada de modo que seja _extremamente_ provável que pelo menos um dos fragmentos de dados amostrados por cada cliente esteja faltando _se_ menos da metade dos dados estiver realmente disponível. -[Soluções de dimensionamento da camada 2](/layer-2/), como [rollups](/glossary/#rollups), dimensionam a taxa de transferência da rede e latência, processando transações fora da principal camada de execução do Ethereum. Transações off-chain são compactadas e publicadas no Ethereum em lotes. Milhares de transações poderiam acontecer off-chain, mas o Ethereum precisa processar _uma_ transação on-chain associada a cada envio em lote. Isto reduz o congestionamento na camada de base e as taxas para os usuários, ao mesmo tempo que garante transações mais rápidas. +O DAS será usado para garantir que os operadores de rollup tornem seus dados de transação disponíveis após o [EIP-4844](/roadmap/danksharding) ser implementado. Os nós do Ethereum usarão como amostras os dados da transação fornecidos nos blobs aleatoriamente usando o esquema de redundância explicado acima para garantir que todos os dados existam. A mesma técnica também poderá ser utilizada para garantir que os produtores de blocos estejam disponibilizando todos os seus dados para proteger clientes leves. Da mesma forma, na [separação entre proponentes e construtores](/roadmap/pbs), apenas o construtor do bloco seria necessário para processar um bloco inteiro, enquanto outros validadores verificariam usando uma amostragem da disponibilidade de dados. -No entanto, para que o Ethereum garanta a segurança dos rollups, ele precisa de um mecanismo para verificar a validade das transações off-chain. É aqui que a disponibilidade de dados entra em cena. - -[Optimistic rollups](/developers/docs/scaling/optimistic-rollups/) publicam dados de transações compactados no Ethereum como `calldata`. Isso permite que qualquer pessoa verifique o estado do rollup e também forneça garantias de validade da transação. Se uma transação for inválida, um verificador poderá usar os dados de transação disponíveis para criar uma [prova de fraude](/glossary/#fraud-proof) para desafiá-la. - -[ZK-rollups (rollups de conhecimento zero)](/developers/docs/scaling/zk-rollups) não precisam publicar dados de transação, já que as [provas de validação de conhecimento zero](/glossary/#zk-proof) garantem a exatidão das transições de estado. No entanto, não podemos garantir a funcionalidade do ZK-rollup (ou interagir com ele) sem ter acesso aos dados do seu estado. - -Por exemplo, os usuários não podem saber os saldos deles se um operador retiver detalhes sobre o estado do rollup. Eles tampouco podem realizar atualizações de estado utilizando informações contidas em um bloco recém-adicionado. - -## Tipos de sistemas de disponibilidade de dados em blockchains {#types-of-data-availability-systems-in-blockchains} - -### Disponibilidade de dados on-chain {#on-chain-data-availability} - -A solução padrão para resolver a disponibilidade de dados é forçar os produtores de bloco a publicar todos os dados de transação on-chain e ter nós validadores baixando-os. A disponibilidade de dados on-chain é uma característica das "blockchain monolíticas" que gerenciam disponibilidade de dados, execução de transações e consenso, em uma única camada. Armazenando dados de estado de forma redundante em toda a rede, o protocolo Ethereum garante que os nós tenham acesso aos dados necessários para reproduzir transações, verificar atualizações de estado e sinalizar transições de estado inválidas. - -No entanto, a disponibilidade de dados on-chain coloca um gargalo no dimensionamento. As blockchains monolíticas geralmente têm velocidades de processamento lentas, pois os nós devem baixar todos os blocos e reproduzir as mesmas transações. Elas também requerem nós completos para armazenar quantidades crescentes de estado, uma tendência que poderia afetar a descentralização. Se o estado do Ethereum aumentar vertiginosamente, os validadores deverão investir em máquinas maiores, o que provavelmente reduziria o número de pessoas que desejam executar um nó de validação. - -### Disponibilidade de dados off-chain {#off-chain-data-availability} - -Sistemas de disponibilidade de dados off-chain movem o armazenamento de dados para fora da blockchain: produtores de blocos não publicam dados da transação on-chain, mas providenciam um compromisso criptográfico para provar a disponibilidade dos dados. Este é um método usado por [blockchains modulares](https://celestia.org/learn/basics-of-modular-blockchains/modular-and-monolithic-blockchains/), em que a cadeia gerencia algumas tarefas, como a execução e o consenso das transações e descarrega outros (por exemplo, disponibilidade de dados) para outra camada. - -Muitas soluções de dimensionamento adotam uma abordagem modular separando a disponibilidade de dados do consenso e execução, já que isso é considerado o caminho ideal para dimensioar blockchains sem aumentar os requisitos do nó. Por exemplo, [validiums](/developers/docs/scaling/validium/) e [plasma](/developers/docs/scaling/plasma/) usam armazenamento off-chain para reduzir a quantidade de dados publicados on-chain. - -Embora a disponibilidade de dados off-chain melhora a eficiência, ela tem implicações negativas na descentralização, segurança e confiança. Por exemplo, os participantes em validiums e cadeias plasma devem confiar que os produtores de blocos não incluam transações inválidas nos blocos propostos. Os produtores de blocos podem agir maliciosamente (ou seja, antecipando transições de estado inválidas) e tentar desafiar transações maliciosas retendo dados do estado. - -Devido aos problemas associados ao armazenamento off-chain, algumas soluções de dimensionamento armazenam os dados de transações na blockchain principal, como o Ethereum. Optimistic rollups e ZK-rollups, por exemplo, não armazenam dados de transação, mas usam a rede principal do Ethereum como uma camada de disponibilidade de dados. - -## Quais são algumas soluções para o problema da disponibilidade de dados? {#solutions-to-data-availability-problem} - -Como mencionado, o problema da disponibilidade de dados diz respeito à capacidade de verificar a disponibilidade dos dados de transação para um bloco recentemente proposto. As soluções para este problema usam alguns mecanismos para garantir a disponibilidade de dados. - -### Amostragem da disponibilidade de dados {#data-availability-sampling} - -A amostragem da disponibilidade de dados é um mecanismo criptográfico para garantir a disponibilidade de dados. A amostragem da disponibilidade de dados permite que os nós de blockchain verifiquem se os dados de um bloco proposto estão disponíveis sem ter que baixar todo o bloco. - -Em um sistema DAS, um nó pega de amostra pequenos pedaços aleatórios de um bloco em várias rodadas para verificar a disponibilidade de dados. Com muitos nós amostrando diferentes partes de um bloco simultaneamente, sua disponibilidade pode ser verificada com alta certeza estatística. - -Quando aplicado a blockchains, como i Ethereum, a amostragem da disponibilidade de dados garante que os clientes leves também participem na garantia da segurança e funcionalidade da cadeia. Clientes leves podem rodar sem hardware caro, tornando mais fácil para qualquer um validar na rede Ethereum. - -[Mais sobre amostragem da disponibilidade de dados.](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling) - -#### Provas de disponibilidade de dados {#data-availability-proofs} +### Comitês de disponibilidade de dados {#data-availability-committees} -Embora a amostragem da disponibilidade de dados dá garantias estatísticas da disponibilidade de um bloco, um nó malicioso ainda pode ocultar alguns dados. As técnicas de DAS só provam que a maioria dos dados do bloco está disponível, não que todo o bloco esteja disponível. E muitos danos podem advir dos produtores de blocos escondendo até uma pequena quantidade de dados de transações. +Os Comitês de Disponibilidade de Dados (DACs, do inglês Data Availability Committees) são partes confiáveis que fornecem ou atestam a disponibilidade de dados. DACs podem ser usados em vez de, [ou em combinação com](<(https://hackmd.io/@vbuterin/sharding_proposal#Why-not-use-just-committees-and-not-DAS)>) DAS. As garantias de segurança que chegam aos comitês dependem de configuração específica. O Ethereum usa amostras de subconjuntos de validadores escolhidos aleatoriamente para atestar a disponibilidade de dados para nós leves, por exemplo. -Para resolver esse problema, combinamos a amostragem da disponibilidade de dados com [codificação de eliminação](https://en.wikipedia.org/wiki/Erasure_code) para criar "provas da disponibilidade de dados". A codificação por eliminação (erasure coding) é uma técnica que nos permite duplicar um conjunto de dados adicionando peças redundantes (chamado códigos de eliminação). Se os dados originais forem perdidos, os códigos eliminados poderão ser usados para reconstruir a parte original dos dados. +DACs também são usados por alguns validiums. O DAC é um conjunto confiável de nós que armazena cópias de dados offline. O DAC é necessário para disponibilizar os dados em caso de litígio. Os membros do DAC também publicam certificados na cadeia para provar que os referidos dados estão efetivamente disponíveis. Alguns validiums substituem os DACs por um sistema validador de prova de participação (proof-of-stake ou PoS). Aqui, qualquer pessoa pode se tornar um validador e armazenar dados off-chain. No entanto, eles devem fornecer uma “caução”, que é depositada em um contrato inteligente. No caso de comportamento malicioso, por exemplo, o validador retendo dados, a caução pode ser interrompida. Os comitês de disponibilidade de dados da prova de participação são consideravelmente mais seguros do que os DACs regulares, porque incentivam diretamente um comportamento honesto. -Quando implementado em blockchains, os códigos eliminados melhoram a disponibilidade de dados porque uma pequena fração dos dados é suficiente para reconstruir toda a transação definida em um bloco. Neste sistema, um produtor de bloco malicioso precisaria reter mais de 50% do bloco para executar um ataque de retração. Anteriormente, um produtor de blocos só precisaria pegar 1% dos dados do bloco para agir maliciosamente. +## Disponibilidade de dados e nós leves {#data-availability-and-light-nodes} -Com blocos codificados por eliminação, os clientes leves têm certeza estatística de que todos os dados do bloco foram publicados na rede. Isso também significa que clientes leves não precisam confiar em nós completos para alertá-los da indisponibilidade de um bloco. +Os [Nós leves](/developers/docs/nodes-and-clients/light-clients) precisam validar a exatidão dos cabeçalhos do bloco que recebem sem baixar os dados do bloco. O custo dessa leveza é a incapacidade de verificar de forma independente os cabeçalhos do bloco reexecutando as transações localmente da maneira que os nós completos fazem. -[Mais sobre provas de disponibilidade de dados.](https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding) +Os nós leves do Ethereum confiam em conjuntos aleatórios de 512 validadores que foram atribuídos a um _comitê de sincronização_. O comitê de sincronização atua como um DAC que sinaliza aos clientes leves que os dados no cabeçalho estão corretos usando uma assinatura criptográfica. O comitê de sincronização é atualizado diariamente. Cada cabeçalho do bloco alerta os nós leves, indicando quais validadores serão destinados a assinar o _próximo_ bloco, para não serem enganados confiando em um grupo malicioso fingindo ser o verdadeiro comitê de sincronização. -### Comitês de disponibilidade de dados {#data-availability-committees} +No entanto, o que acontece se um invasor _conseguir_ de alguma forma passar um cabeçalho de bloco malicioso para clientes leves e convencê-los de que foi assinado por um comitê de sincronização honesto? Nesse caso, o invasor poderia incluir transações inválidas e o cliente leve as aceitaria cegamente, pois não verifica de forma independente todas as alterações de estado resumidas no cabeçalho do bloco. Para se proteger contra isso, o cliente leve pode usar provas de fraude. -Validações validiums armazenam dados de transações off-chain com um produtor de blocos, tornando-os centralizados em certa medida. Isto reduz a descentralização e a segurança, uma vez que o produtor do bloco pode publicar transações inválidas e ocultar o verdadeiro estado do rollup ao esconder dados de transação. +Essas provas de fraude funcionam da seguinte maneira: um nó completo observa uma transição de estado inválido sendo espalhada pela rede, que poderia rapidamente gerar uma pequena parte de dados demonstrando que uma transição de estado proposta não poderia surgir de um determinado conjunto de transações e transmitir esses dados aos seus pares. Os nós leves poderiam pegar essas provas de fraude e usá-las para descartar cabeçalhos de bloco ruins, garantindo que permaneçam na mesma cadeia honesta que os nós completos. -Alguns validiums tentam resolver este problema solicitando aos produtores de blocos que armazenem dados de transações com terceiros confiáveis, que formam o Comitê de Disponibilidade de Dados (DAC). As histórias do DAC são cópias de dados off-chain offline, mas são necessárias para torná-los disponíveis em caso de disputa. Os membros do DAC também publicam certificados na cadeia para provar que os referidos dados estão efetivamente disponíveis. +Isso depende de nós completos com acesso a dados completos da transação. Um invasor que transmite um cabeçalho de bloco inválido e também falha em disponibilizar os dados da transação seria capaz de impedir que os nós completos gerassem provas de fraude. Os nós completos poderiam conseguir sinalizar um aviso sobre um bloco ruim, mas não poderiam fazer validar seu aviso com uma prova, pois os dados não foram disponibilizados para gerar a prova! -[Mais sobre comitês de disponibilidade de dados.](https://medium.com/starkware/data-availability-e5564c416424) +A solução para esse problema de disponibilidade de dados é o DAS. Nós leves baixam partes aleatórias muito pequenas dos dados de estado completos e usam as amostras para verificar se o conjunto completo de dados está disponível. A probabilidade real de assumir incorretamente a disponibilidade total dos dados após baixar N blocos aleatórios pode ser calculada ([para 100 partes, a chance é de 10^-30](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html), ou seja, incrivelmente improvável). -### Comitês de disponibilidade de dados da prova de participação {#proof-of-stake-data-availability-committees} +Mesmo nesse cenário, os ataques que retêm apenas alguns bytes poderiam passar despercebidos pelos clientes que fazem solicitações de dados aleatórios. A codificação de eliminação (remoção segura e permanente de dados de contratos) corrige isso reconstruindo pequenas partes de dados ausentes que podem ser usadas para verificar as alterações de estado propostas. Uma prova de fraude poderia então ser construída usando os dados reconstruídos, evitando que clientes leves aceitem cabeçalhos ruins. -Embora os comitês de disponibilidade de dados sejam melhores que o estado atual em um validium, as suposições de confiança ainda persistem. E se o DAC conspirar com o produtor do bloco para reter os dados da transação? Os DACs geralmente são pequenos, aumentando o risco de conflito e a possibilidade de um ator externo comprometer o grupo. +**Nota:** DAS e provas de fraude ainda não foram implementados para clientes leves da prova de participação do Ethereum, mas estão no roteiro, muito provavelmente assumindo a forma de provas baseadas em ZK-SNARK. Os clientes leves de hoje dependem de uma forma de DAC: eles verificam as identidades do comitê de sincronização e, em seguida, confiam nos cabeçalhos de bloco assinados que recebem. -Alguns validiums substituem os DACs por um sistema validador de prova de participação (proof-of-stake ou PoS). Aqui, qualquer pessoa pode se tornar um validador e armazenar dados off-chain. No entanto, eles devem fornecer uma “caução”, que é depositada em um contrato inteligente. No caso de comportamento malicioso, por exemplo, o validador retendo dados, a caução pode ser interrompida. +## Disponibilidade de dados e rollups de camada 2 {#data-availability-and-layer-2-rollups} -Os comitês de disponibilidade de dados da prova de participação são consideravelmente mais seguros do que os DACs comuns. Eles não são apenas sem permissão e sem confiança, mas também têm incentivos bem elaborados para encorajar um comportamento honesto. +[As soluções de escalabilidade de Camada 2](/layer-2/), como [rollups](/glossary/#rollups), reduzem os custos de transação e aumentam o rendimento do Ethereum processando transações off-chain. As transações de rollup são compactadas e postadas no Ethereum em lotes. Os lotes representam milhares de transações individuais off-chain em uma única transação no Ethereum. Isso reduz o congestionamento na camada base e reduz as taxas para os usuários. -[Mais informações sobre os comitês de disponibilidade de dados da prova de participação.](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf) +No entanto, só é possível confiar nas transações “resumidas” publicadas no Ethereum se a mudança de estado proposta puder ser verificada de forma independente e confirmada como resultado da aplicação de todas as transações individuais off-chain. Se os operadores de rollup não disponibilizarem os dados da transação para essa verificação, eles poderão enviar dados incorretos para o Ethereum. -## Ethereum e o futuro da disponibilidade de dados {#ethereum-and-the-future-of-data-availability} +[Rollups otimistas](/developers/docs/scaling/optimistic-rollups/) publicam dados de transação compactados no Ethereum e esperam algum tempo (normalmente 7 dias) para permitir que verificadores independentes confiram os dados. Se alguém identificar um problema, poderá gerar uma prova de fraude e usá-la para contestar o rollup. Isso faria com que a cadeia fosse revertida e omitisse o bloco inválido. Isso só é possível se houver dados disponíveis. Atualmente, os dados são disponibilizados de forma permanente como `CALLDATA`, que reside permanentemente on-chain. No entanto, o EIP-4844 em breve permitirá que os rollups publiquem seus dados de transação em um armazenamento de blob mais barato. Esse armazenamento não é permanente. Os verificadores independentes terão que consultar os blobs e reportar seus desafios entre 1 e 3 meses antes de os dados serem excluídos da camada 1 do Ethereum. A disponibilidade dos dados só é garantida pelo protocolo Ethereum para esse curto espaço de tempo fixo. Depois disso, ela é de responsabilidade de outras entidades do ecossistema Ethereum. Qualquer nó pode verificar a disponibilidade de dados usando DAS, ou seja, baixando pequenas amostras aleatórias dos dados do blob. -Embora os rollups possam aumentar a taxa de transferência com computação off-chain, sua capacidade é limitada pela vazão dos dados na blockchain subjacente. Se os rollups usarem o Ethereum como uma camada de disponibilidade de dados, eles deverão aumentar seus recursos de armazenamento e processamento de dados. +[ZK-rollups (rollups de conhecimento zero)](/developers/docs/scaling/zk-rollups) não precisam publicar dados de transação, já que as [provas de validação de conhecimento zero](/glossary/#zk-proof) garantem a exatidão das transições de estado. No entanto, a disponibilidade dos dados ainda é um problema, pois não podemos garantir a funcionalidade do ZK-rollup (ou interagir com ele) sem acesso aos seus dados de estado. Por exemplo, os usuários não podem saber os saldos deles se um operador retiver detalhes sobre o estado do rollup. Eles tampouco podem realizar atualizações de estado utilizando informações contidas em um bloco recém-adicionado. -[Particionamento](/roadmap/danksharding/) (sharding) é um método proposto para aumentar a taxa de transferência de dados na camada de execução do Ethereum. Com o particionamento, a rede é dividida em um número selecionado de subcadeias, cada uma com um conjunto dedicado de validadores. +## Disponibilidade de dados vs. recuperabilidade de dados {#data-availability-vs-data-retrievability} -Os validadores só precisarão executar nós completos para seus shards e executar em capacidade de cliente leve para outros shards. O particionamento aumenta o espaço de dados disponível para rollups, pois o trabalho de armazenamento de dados é dividido em diferentes fragmentos. +Disponibilidade de dados é diferente de recuperabilidade de dados. A disponibilidade de dados é a garantia de que nós completos conseguiram acessar e verificar o conjunto completo de transações associadas a um bloco específico. Isso não significa necessariamente que os dados ficarão acessíveis para sempre. -Mas o particionamento de dados apresenta um novo problema: “E se os validadores em um fragmento se tornarem maliciosos e começarem a processar transições de estado inválido?”. Isso é possível porque os nós completos não têm mais acesso aos mesmos dados da transação, como é o caso atualmente. A implementação do particionamento de dados requer a criação de um sistema para nós para verificar a disponibilidade de dados em outros fragmentos sem baixar blocos, caso contrário, o objetivo do particionamento é anulado. +Recuperabilidade de dados é a capacidade de os nós recuperarem _informações históricas_ da blockchain. Esses dados históricos não são necessários para verificar novos blocos, apenas para sincronizar nós completos do bloco de origem ou servir solicitações históricas específicas. -Para resolver esse problema, novas propostas de dimensionamento para Ethereum, como [Danksharding](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq), dependem da amostragem de disponibilidade de dados para verificar se todo o o conteúdo de um blob foi visto pela rede. Este sistema alivia os nós individuais do ônus de baixar e validar tudo diretamente. +A preocupação do protocolo principal Ethereum é a disponibilidade de dados, e não a recuperação de dados. A capacidade de recuperar dados pode ser fornecida por uma pequena população de nós de arquivos executados por terceiros ou pode ser distribuída pela rede usando um armazenamento de arquivos descentralizado, como o [Portal Network](https://www.ethportal.net/). ## Leitura adicional {#further-reading} - [O que é disponibilidade de dados?](https://medium.com/blockchain-capital-blog/wtf-is-data-availability-80c2c95ded0f) - [O que é a disponibilidade de dados?](https://coinmarketcap.com/alexandria/article/what-is-data-availability) -- [O problema da disponibilidade de dados](https://blog.polygon.technology/the-data-availability-problem-6b74b619ffcc/) - [O cenário da disponibilidade de dados off-chain do Ethereum](https://blog.celestia.org/ethereum-off-chain-data-availability-landscape/) - [Uma cartilha sobre verificações de disponibilidade de dados](https://dankradfeist.de/ethereum/2019/12/20/data-availability-checks.html) - [Uma explicação da proposta de particionamento + DAS](https://hackmd.io/@vbuterin/sharding_proposal#ELI5-data-availability-sampling) +- [Uma nota sobre disponibilidade de dados e codificação de exclusão](https://github.com/ethereum/research/wiki/A-note-on-data-availability-and-erasure-coding#can-an-attacker-not-circumvent-this-scheme-by-releasing-a-full-unavailable-block-but-then-only-releasing-individual-bits-of-data-as-clients-query-for-them) +- [Comitês de disponibilidade de dados.](https://medium.com/starkware/data-availability-e5564c416424) +- [Comitês de disponibilidade de dados da prova de participação.](https://blog.matter-labs.io/zkporter-a-breakthrough-in-l2-scaling-ed5e48842fbf) +- [Soluções para o problema de recuperação de dados](https://notes.ethereum.org/@vbuterin/data_sharding_roadmap#Who-would-store-historical-data-under-sharding) diff --git a/src/content/translations/pt-br/developers/docs/evm/evm.png b/src/content/translations/pt-br/developers/docs/evm/evm.png new file mode 100644 index 00000000000..2c503d3c75d Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/evm/evm.png differ diff --git a/src/content/translations/pt-br/developers/docs/evm/gas.png b/src/content/translations/pt-br/developers/docs/evm/gas.png new file mode 100644 index 00000000000..9e7a0f9176e Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/evm/gas.png differ diff --git a/src/content/translations/pt-br/developers/docs/ides/index.md b/src/content/translations/pt-br/developers/docs/ides/index.md index 80163996763..24988f5c241 100644 --- a/src/content/translations/pt-br/developers/docs/ides/index.md +++ b/src/content/translations/pt-br/developers/docs/ides/index.md @@ -20,7 +20,7 @@ Se você quer brincar com o código antes de [configurar um ambiente de desenvol - [Documentação](https://chainide.gitbook.io/chainide-english-1/) - [Fórum de ajuda](https://forum.chainide.com/) -**[Replit (Solidity Starter - Beta)](https://replit.com/@replit/Solidity-starter-beta)** - \*\*\_Um ambiente de desenvolvimento personalizável para Ethereum com hot reloading, verificação de erros e suporte a rede de testes de primeira classe +**[Replit (Solidity Starter - Beta)](https://replit.com/@replit/Solidity-starter-beta)** - **_Um ambiente de desenvolvimento personalizável para Ethereum com hot reloading, verificação de erros e suporte a rede de testes de primeira classe_** - [Documentação](https://docs.replit.com/) diff --git a/src/content/translations/pt-br/developers/docs/mev/index.md b/src/content/translations/pt-br/developers/docs/mev/index.md index 4acadeb818c..cbb66dd8e6f 100644 --- a/src/content/translations/pt-br/developers/docs/mev/index.md +++ b/src/content/translations/pt-br/developers/docs/mev/index.md @@ -8,7 +8,7 @@ Valor Máximo Extraível (MEV, na sigla em inglês) expressa o valor máximo que ### Valor máximo extraível {#miner-extractable-value} -O valor máximo extraível foi aplicado pela primeira vez no contexto de [prova de trabalho](/developers/docs/consensus-mechanisms/pow/) e inicialmente referido como "valor extraível do minerador". Isto porque na prova de trabalho, os mineradores controlam a inclusão, exclusão e ordenação das transações. No entanto, desde a transição para a prova de participação via a [Fusão](/roadmap/merge), os validadores foram responsáveis por essas funções, e a mineração não faz mais parte do protocolo Ethereum. Como os métodos de extração de valor ainda existem, o termo "valor máximo extraível" agora é usado. +O valor máximo extraível foi aplicado pela primeira vez no contexto de [prova de trabalho](/developers/docs/consensus-mechanisms/pow/) e inicialmente referido como "valor extraível do minerador". Isto porque na prova de trabalho, os mineradores controlam a inclusão, exclusão e ordenação das transações. No entanto, desde a transição para a prova de participação por meio do [The Merge (A Fusão)](/roadmap/merge), os validadores têm sido responsáveis por essas funções, e a mineração não faz mais parte do protocolo Ethereum. Como os métodos de extração de valor ainda existem, o termo "valor máximo extraível" agora é usado. ## Pré-Requisitos {#prerequisites} @@ -112,7 +112,7 @@ A extração MEV teve um grande crescimento no início de 2021, o que resultou e Enquanto muitos buscadores ainda estão ganhando um bom dinheiro com o MEV, à medida que as oportunidades se tornam mais conhecidas e mais e mais buscadores competem pela mesma oportunidade, os validadores irão capturar cada vez mais receita total do MEV (porque o mesmo tipo de leilão de gás descrito originalmente acima também ocorre em Flashbots, embora de forma particular, e os validadores irão capturar a receita de gás resultante). O MEV também não é exclusivo da Ethereum, e conforme as oportunidades se tornam mais competitivas no Ethereum, os buscadores estão migrando para blockchains alternativas, como a Binance Smart Chain, onde oportunidades de MEV semelhantes às que estão na Ethereum existem com menos concorrência. -Por outro lado, a transição da prova de trabalho (proof-of-work) para prova de participação (proof-of-stake) e o esforço contínuo para dimensionar a Ethereum usando rollups (agrupamentos) e sharding (particionamentos) mudam o cenário do MEV de maneira ainda pouco clara. Ainda não se sabe bem de que maneira ter proponentes de bloco garantidos conhecidos com pouca antecedência altera a dinâmica da extração de MEV em comparação com o modelo probabilístico em prova de trabalho ou como isso será interrompido quando [a eleição de líder secreto único](https://ethresear.ch/t/secret-non-single-leader-election/11789) e [a tecnologia de validação distribuída](https://github.com/ethereum/distributed-validator-specs) forem implementados. Da mesma forma, resta saber quais são as oportunidades de MEV existentes quando a maioria das atividades do usuário é transferida do Ethereum para seus rollups e fragmentos de camada 2. +Por outro lado, a transição da prova de trabalho para prova de participação e o esforço contínuo para escalar o Ethereum usando rollups mudam todo o panorama do MEV de maneiras que ainda não estão claras. Ainda não se sabe bem de que maneira ter proponentes de bloco garantidos conhecidos com pouca antecedência altera a dinâmica da extração de MEV em comparação com o modelo probabilístico na prova de trabalho ou como isso será interrompido quando [a eleição de líder secreto único](https://ethresear.ch/t/secret-non-single-leader-election/11789) e [a tecnologia de validador distribuído](/staking/dvt/) forem implementados. Da mesma forma, resta saber quais são as oportunidades de MEV existentes quando a maioria das atividades do usuário é transferida do Ethereum para seus rollups e fragmentos de camada 2. ## MEV na prova de participação (PoS) do Ethereum {#mev-in-ethereum-proof-of-stake} @@ -122,7 +122,7 @@ Conforme explicado, o MEV tem implicações negativas para a experiência geral No Ethereum pós-fusão, os validadores (tendo feito depósitos de segurança de 32 ETH) chegam a um consenso sobre a validade dos blocos adicionados à Beacon Chain. Como 32 ETH podem estar fora do alcance de muitos, [entrar em um staking pool](/staking/pools/) pode ser uma opção mais viável. No entanto, uma distribuição saudável de [stakers individuais](/staking/solo/) é ideal, pois mitiga a centralização dos validadores e melhora a segurança do Ethereum. -No entanto, acredita-se que a extração MEV seja capaz de acelerar a centralização de validadores. Isso em parte porque os validadores [ganham menos por propor blocos](/roadmap/merge/issuance/#how-the-merge-impacts-ETH-supply) do que os mineradores atualmente ganham. A extração MEV pode em muito [influenciar os ganhos do validador](https://github.com/flashbots/eth2-research/blob/main/notebooks/mev-in-eth2/eth2-mev-calc.ipynb) após a Fusão. +No entanto, acredita-se que a extração MEV seja capaz de acelerar a centralização de validadores. Isso se deve em parte porque, como os validadores [ganham menos por propor blocos](/roadmap/merge/issuance/#how-the-merge-impacts-ETH-supply) do que os mineradores atualmente, a extração de MEV pode em muito [influenciar os ganhos do validador](https://github.com/flashbots/eth2-research/blob/main/notebooks/mev-in-eth2/eth2-mev-calc.ipynb) após o The Merge (A Fusão). Staking pools maiores provavelmente terão mais recursos para investir em otimizações necessárias para capturar oportunidades de MEV. Quanto mais MEV essas pools extraem, mais recursos eles têm para melhorar suas capacidades de extração MEV (e aumentar a receita geral), criando essencialmente [economias de escala](https://www.investopedia.com/terms/e/economiesofscale.asp#). @@ -210,7 +210,7 @@ Alguns projetos, como MEV Boost, usam a Builder API como parte de uma estrutura ## Leitura adicional {#further-reading} - [Valor extraível da mineração (MEV)?](https://blog.chain.link/what-is-miner-extractable-value-mev/) -- [MEV e Mim](https://research.paradigm.xyz/MEV) +- [MEV e Mim](https://www.paradigm.xyz/2021/02/mev-and-me) - [O Ethereum é uma Floresta Sombria](https://www.paradigm.xyz/2020/08/ethereum-is-a-dark-forest/) - [Escapando da Floresta Sombria](https://samczsun.com/escaping-the-dark-forest/) - [Flashbots: Superando a crise MEV](https://medium.com/flashbots/frontrunning-the-mev-crisis-40629a613752) diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/eth1eth2client.png b/src/content/translations/pt-br/developers/docs/nodes-and-clients/eth1eth2client.png new file mode 100644 index 00000000000..dd4a9fe2bbb Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/nodes-and-clients/eth1eth2client.png differ diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/index.md b/src/content/translations/pt-br/developers/docs/nodes-and-clients/index.md index b98eb9d951c..9993949d5de 100644 --- a/src/content/translations/pt-br/developers/docs/nodes-and-clients/index.md +++ b/src/content/translations/pt-br/developers/docs/nodes-and-clients/index.md @@ -122,9 +122,9 @@ Se você é mais que um usuário técnico, mergulhe em mais detalhes e opções ## Alternativas {#alternatives} -Configurar seu próprio nó pode custar tempo e recursos, mas nem sempre você precisa executar sua própria instância. Nesse caso, você pode usar um provedor de API terceirizado como [Infura](https://infura.io), [Alchemy](https://alchemyapi.io), [Chainstack](https://chainstack.com), [QuikNode](https://www.quiknode.io), [Tenderly](https://tenderly.co/web3-gateway), [Blasto](https://blastapi.io/), [DRPC](https://drpc.org/) ou [GetBlock](https://getblock.io/). Para obter uma visão geral do uso desses serviços, confira [nós como serviço](/developers/docs/nodes-and-clients/nodes-as-a-service/). +Configurar seu próprio nó pode custar tempo e recursos, mas nem sempre você precisa executar sua própria instância. Nesse caso, é possível usar um provedor de APIs externo. Para obter uma visão geral do uso desses serviços, confira [nós como serviço](/developers/docs/nodes-and-clients/nodes-as-a-service/). -Se alguém executa um nó do Ethereum com uma API pública em sua comunidade, você pode apontar suas carteiras leves (como MetaMask) para um nó da comunidade [via RPC personalizado](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node) e ganhar mais privacidade do que com alguns terceiros aleatórios de confiança. +Se alguém executar um nó do Ethereum com uma API pública em sua comunidade, você pode apontar suas carteiras para um nó da comunidade por meio de um RPC personalizado. Por outro lado, se você executar um cliente, você pode compartilhá-lo com quem precisar. diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/node-architecture/node-architecture-text-background.png b/src/content/translations/pt-br/developers/docs/nodes-and-clients/node-architecture/node-architecture-text-background.png new file mode 100644 index 00000000000..2a6a08dc937 Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/nodes-and-clients/node-architecture/node-architecture-text-background.png differ diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md b/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md index dd433a294cf..55a4e2138d9 100644 --- a/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md +++ b/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes-as-a-service/index.md @@ -143,10 +143,24 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - Painel - Suporte Direto 24/7 - Pague em criptomoedas (Enterprise) +- [DRPC](https://drpc.org/) + - [Documentação](https://docs.drpc.org/) + - Recursos + - Nós RPC descentralizados + - Mais de 15 provedores de nós + - Balanceamento de nós + - Unidades de computação ilimitadas por mês na camada gratuita + - Verificação de dados + - Pontos de extremidade personalizados + - Pontos de extremidade Http e WSS + - Chaves ilimitadas (camada paga e gratuita) + - Opções de fallback flexíveis + - [Ponto de extremidade público](https://eth.drpc.org) + - Nós de arquivos compartilhados gratuitos - [**GetBlock**](https://getblock.io/) - [Documentação](https://getblock.io/docs/get-started/authentication-with-api-key/) - Recursos - - Acesso a mais de 40 nós da cadeia de blocos + - Acesso a mais de 40 nós de blockchain - 40.000 solicitações diárias gratuitas - Número ilimitado de chaves de API - Alta velocidade de conexão em 1GB/segundo @@ -164,7 +178,7 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - Nós completos dedicados - Tempo de sincronização rápido para implantações dedicadas - Suporte direto 24/7 - - Acesso a mais de 50 nós da cadeia de blocos + - Acesso a mais de 50 nós da blockchain - [**Infura**](https://infura.io/) - [Documentação](https://infura.io/docs) - Recursos @@ -178,19 +192,19 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - Recursos - Nível inicial gratuito - Implementação do nó Ethereum em um clique - - Clientes e algoritmos personalizáveis (Geth, Quorum & Besu || PoA, IBFT & Raft) + - Clientes e algoritmos personalizáveis (Geth, Quorum e Besu || PoA, IBFT e Raft) - Mais de 500 APIs administrativas e de serviço - Interface RESTful para envio de transação Ethereum (com Apache Kafka) - Fluxos de saída para entrega de eventos (com Apache Kafka) - - Profunda coleção de serviços "fora da cadeia" e auxiliares (por exemplo, transporte de mensagens criptografadas bilaterais) - - Encaminhamento de rede com controle de governança e acesso baseado em funções - - Sofisticado gerenciamento de usuários para administradores e usuários finais + - Profunda coleção de serviços “fora da cadeia” e auxiliares (por exemplo, transporte de mensagens criptografadas bilaterais) + - Integração de rede direta com controle de governança e acesso baseado em funções + - Gerenciamento de usuários sofisticado para administradores e usuários finais - Infraestrutura altamente escalonável, resiliente e de nível empresarial - Gerenciamento de chaves privadas HSM - - Tethering da Rede principal Ethereum + - Compartilhamento de Internet da Mainnet (Rede principal) Ethereum - Certificações de tipo 2, ISO 27k e SOC 2 - Configuração dinâmica de execução (por exemplo, adicionar integrações na nuvem, alterar entradas do nó, etc.) - - Suporte para orquestrações multinuvem, multirregião e de implantação híbrida + - Suporte a orquestrações multinuvem, multirregião e de implantação híbrida - Preços simples baseados em SaaS por hora - SLAs e suporte 24x7 - [**Moralis**](https://moralis.io/) @@ -208,17 +222,17 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - [**NodeReal MegaNode**](https://nodereal.io/) - [Documentação](https://docs.nodereal.io/nodereal/meganode/introduction) - Recursos - - Serviços de API RPC confiáveis, rápidos e escalonáveis - - API aprimorada para desenvolvedores web3 + - Serviços da API RPC confiáveis, rápidos e escalonáveis + - API aprimorada para desenvolvedores Web3 - Suporte multicadeias - - Comece de graça + - Comece gratuitamente - [**NOWNodes**](https://nownodes.io/) - [Documentação](https://documenter.getpostman.com/view/13630829/TVmFkLwy) - Recursos - - Acesso a mais de 50 nós da cadeia de blocos - - Chave de API Gratuita - - Exploradores de Bloco - - Tempo de Resposta da API ⩽1 segundo + - Acesso a mais de 50 nós da blockchain + - Chave de API gratuita + - Exploradores de Blocos + - Tempo de Resposta da API ⩽ 1 segundo - Equipe de suporte 24/7 - Gerente de Conta Pessoal - Nós compartilhados, de arquivo, de cópia de segurança e dedicados @@ -229,10 +243,10 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - 1 milhão de solicitações gratuitas por dia (por ponto de extremidade, máx. 2) - [Pontos de extremidade públicos](https://docs.pokt.network/home/resources/public-rpc-endpoints) - Programa Pre-Stake+ (se você precisar de mais de 1 milhão de solicitações por dia) - - Mais de 15 cadeias de blocos suportadas + - Mais de 15 blockchains suportadas - Mais de 6.400 nós com ganhos de POKT por atender a aplicativos - - Nó de arquivamento, nó de arquivamento com rastreamento e suporte a nó de rede de testes - - Diversidade do cliente do nó da rede principal Ethereum + - Nó de arquivamento, nó de arquivamento com rastreamento e suporte a nós na Mainnet (Rede principal) + - Diversidade do cliente do nó da Mainnet (Rede principal) Ethereum - Nenhum ponto único de falha - Sem tempo de inatividade - Tokenomics rentáveis e perto de zero (participação de POKT uma vez para a largura de banda da rede) @@ -240,24 +254,24 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - Balanceamento de carga incorporado ao protocolo - Dimensiona infinitamente o número de solicitações por dia e nós por hora conforme o uso - A opção mais privada e resistente à censura - - Suporte prático para os desenvolvedores - - Painel e ferramentas de análise [Pocket Portal](https://bit.ly/ETHorg_POKTportal) + - Suporte prático para desenvolvedores + - Painel e ferramentas de análise do [Pocket Portal](https://bit.ly/ETHorg_POKTportal) - [**QuickNode**](https://www.quicknode.com) - [Documentação](https://www.quicknode.com/docs/) - Recursos - Desempenho e confiabilidade líder do setor - - Suporte técnico 24/7 e comunidade Discord de desenvolvedores - - Balanceamento geográfico, multinuvem/metal, rede de baixa latência - - Suporte de multicadeia (Optimism, Arbitrum, Polygon + 11 outros) + - Suporte técnico 24/7 e comunidade de desenvolvedores do Discord + - Equilibrado geograficamente, multinuvem/metal, rede de baixa latência + - Suporte multicadeia (Optimism, Arbitrum, Polygon + 11 outros) - Camadas intermediárias para velocidade e estabilidade (roteamento de chamadas, cache, indexação) - Monitoramento de contratos inteligentes via Webhooks - Painel intuitivo, conjunto de análises, compositor RPC - Funcionalidades avançadas de segurança (JWT, mascaramento, lista de permissões) - Dados e API de análise de NFT - - [Certificado SOC2](https://www.quicknode.com/security) + - [Certificação SOC2](https://www.quicknode.com/security) - Adequado para desenvolvedores e empresas - [**Rivet**](https://rivet.cloud/) - - [Documentação](https://rivet.readthedocs.io/en/latest/) + - [Documentos](https://rivet.readthedocs.io/en/latest/) - Recursos - Opção de nível gratuito - Dimensione conforme suas necessidades @@ -284,12 +298,12 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - [**Tenderly**](https://tenderly.co/web3-gateway) - [Documentos](https://docs.tenderly.co/web3-gateway/web3-gateway) - Recursos - - Nível gratuito, incluindo 25 milhões de Unidades Tenderly por mês + - Nível gratuito, incluindo 25 milhões de unidades Tenderly por mês - Acesso gratuito aos dados históricos - Cargas de trabalho de leitura pesada até 8x mais rápidas - Acesso de leitura 100% consistente - Pontos de extremidade RPC JSON - - Construtor de requisições RPC baseado em UI e pré-visualização de requisições + - Construtor de solicitações RPC baseado em interface de usuário e pré-visualização de solicitações - Integração rigorosa com as ferramentas de desenvolvimento, depuração e teste do Tenderly - Simulações de transação - Análise de uso e filtragem @@ -302,17 +316,17 @@ Segue uma lista de alguns dos fornecedores de nós para Ethereum mais populares. - Conexão ininterrupta sem tempo de inatividade - Automação do processo - Tarifas gratuitas - - Altos limites que se adaptam a qualquer usuário - - Suporte para vários nós + - Limites altos que se adaptam a qualquer usuário + - Suporte a vários nós - Escalabilidade de recursos - Alta velocidade de processamento - [**ZMOK**](https://zmok.io/) - - [Documentos](https://docs.zmok.io/) + - [Documentação](https://docs.zmok.io/) - Recursos - Front-running como serviço - Mempool de transações globais com métodos de pesquisa/filtragem - - Taxa TX ilimitada e Gás infinita para envio de transações - - O máximo de velocidade na obtenção do novo bloco e leitura da cadeia de blocos + - Taxa TX ilimitada e Gás infinito para envio de transações + - O máximo de velocidade na obtenção do novo bloco e leitura da blockchain - O melhor preço por garantia de chamada de API [**Zeeve**](https://www.zeeve.io/) diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes.png b/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes.png new file mode 100644 index 00000000000..23e310350f3 Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/nodes-and-clients/nodes.png differ diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/diagram.png b/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/diagram.png new file mode 100644 index 00000000000..3654b38d5ed Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/diagram.png differ diff --git a/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/index.md b/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/index.md index c18ef662f6d..9ecb438e9e0 100644 --- a/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/index.md +++ b/src/content/translations/pt-br/developers/docs/nodes-and-clients/run-a-node/index.md @@ -48,55 +48,45 @@ Os clientes Ethereum são capazes de executar em computadores de grau de consumo - Existe a opção para comprar máquinas pré-configuradas - Você tem que fisicamente preparar, manter e solucionar os problemas potenciais que surgirem -Ambas as opções têm vantagens e desvantagens, as quais foram resumidas acima. Caso estiver procurando uma solução para a nuvem, além de muitos provedores tradicionais de computação na nuvem, também existem serviços focados em executar nós. Por exemplo: - -- [QuikNode](https://www.quiknode.io/) -- [Blockdaemon](https://blockdaemon.com) -- [Alchemy](https://www.alchemy.com/) -- [Blast](https://blastapi.io/) -- [GetBlock](https://getblock.io/) -- [NodeReal](https://nodereal.io/) -- [NOWNodes](https://nownodes.io/) - -Confira também [nós como serviço](/developers/docs/nodes-and-clients/nodes-as-a-service/) para obter mais opções de nós hospedados. +Ambas as opções têm vantagens e desvantagens, as quais foram resumidas acima. Caso estiver procurando uma solução para a nuvem, além de muitos provedores tradicionais de computação na nuvem, também existem serviços focados em executar nós. Confira [nós como serviço](/developers/docs/nodes-and-clients/nodes-as-a-service/) para obter mais opções de nós hospedados. #### Hardware {#hardware} No entanto, uma rede descentralizada que resiste à censura não deve depender de provedores na nuvem. Em vez disso, executar seu nó em seu próprio hardware local é mais saudável para o ecossistema. As [estimativas](https://www.ethernodes.org/networkType/Hosting) mostram uma grande parte dos nós executados na nuvem, o que pode se tornar um único ponto de falha. -Os clientes Ethereum podem ser executados no seu computador, laptop, servidor ou até mesmo em um computador de placa única. Enquanto executar clientes em seu computador pessoal é possível. Ter uma máquina dedicada apenas para seu nó pode melhorar significativamente seu desempenho e segurança enquanto minimiza o impacto em seu computador principal. +Os clientes Ethereum podem ser executados no seu computador, laptop, servidor ou até mesmo em um computador de placa única. Enquanto for possível executar clientes em seu computador pessoal, ter um computador dedicado apenas para seu nó poderá melhorar significativamente seu desempenho e segurança, ao mesmo tempo que minimiza o impacto em seu computador principal. -O uso de seu próprio hardware pode ser muito fácil. Existem muitas opções simples, bem como configurações avançadas para pessoas mais técnicas. Então, vamos analisar os requisitos e meios para executar clientes Ethereum em sua máquina. +O uso de seu próprio hardware pode ser muito fácil. Existem muitas opções simples, bem como configurações avançadas para pessoas mais técnicas. Então, vamos analisar os requisitos e meios para executar clientes Ethereum em seu computador. #### Requisitos {#requirements} -Os requisitos de hardware diferem de acordo com o cliente, mas geralmente não são tão altos, já que o nó só precisa ser sincronizado. Não confunda isso com mineração, que requer muito mais poder de computação. Os tempos de sincronização e desempenho, no entanto, melhoram com hardware mais potente. +Os requisitos de hardware diferem conforme o cliente, mas geralmente não são tão altos, já que o nó só precisa ser sincronizado. Não confunda isso com mineração, que requer muito mais poder de computação. No entanto, os tempos de sincronização e desempenho melhoram com hardware mais potente. -Antes de instalar qualquer cliente, certifique-se de que seu computador tem recursos suficientes para executá-lo. Você pode encontrar os requisitos mínimos e recomendados abaixo. +Antes de instalar qualquer cliente, verifique se o seu computador tem recursos suficientes para executá-lo. Você pode encontrar os requisitos mínimos e recomendados abaixo. -O gargalo para seu hardware é, em sua maioria, o espaço em disco. Sincronizar a cadeia de blocos Ethereum é muito intensivo em entrada/saída e requer muito espaço. É melhor ter uma **unidade de estado sólido (SSD)** com centenas de GBs de espaço livre para economizar, mesmo após a sincronização. +O afunilamento do seu hardware é, geralmente, o espaço em disco. Sincronizar a blockchain Ethereum é muito intensivo em termos de entrada/saída e requer muito espaço. É melhor ter uma **unidade de estado sólido (SSD)** com centenas de GBs de espaço livre para economizar, mesmo após a sincronização. O tamanho do banco de dados e a velocidade da sincronização inicial dependem do cliente escolhido, sua configuração e [estratégia de sincronização](/developers/docs/nodes-and-clients/#sync-modes). -Verifique também que sua conexão de Internet não seja limitada devido a um [limite de largura de banda](https://wikipedia.org/wiki/Data_cap). É recomendado usar uma conexão ilimitada para que a sincronização inicial e os dados transmitidos à rede possam exceder seu limite. +Verifique também se sua conexão de Internet não está limitada devido a um [limite de largura de banda](https://wikipedia.org/wiki/Data_cap). É recomendado usar uma conexão ilimitada para que a sincronização inicial e os dados transmitidos à rede possam exceder seu limite. ##### Sistema operacional -Todos os clientes suportam os principais sistemas operacionais: Linux, MacOS e Windows. Isso significa que você pode executar seu nó em computadores ou servidores regulares com o sistema operacional (SO) que melhor atenda às suas necessidades. Certifique-se, porém, de que seu sistema operacional está atualizado para evitar possíveis problemas e vulnerabilidades de segurança. +Todos os clientes dão suporte aos principais sistemas operacionais: Linux, MacOS e Windows. Isso significa que você pode executar seu nó em computadores ou servidores regulares com o sistema operacional (SO) que melhor atenda às suas necessidades. Verifique se o seu sistema operacional está atualizado para evitar possíveis problemas e vulnerabilidades de segurança. ##### Requisitos mínimos - CPU com mais de 2 núcleos -- 8 GB RAM +- 8 GB de RAM - SSD de 2 TB -- - de 10 MBit/s de largura de banda +- Mais de 10 MBit/s de largura de banda ##### Especificações recomendadas - CPU rápida com mais de 4 núcleos -- - de 16 GB de RAM -- SSD rápido com + de 2 TB -- - de 25 MBit/s de largura de banda +- Mais de 16 GB de RAM +- SSD rápido com mais de 2 TB +- Mais de 25 MBit/s de largura de banda O modo de sincronização e o cliente que você escolher afetará os requisitos de espaço, mas estimamos o espaço em disco necessário para cada cliente abaixo. @@ -107,9 +97,9 @@ O modo de sincronização e o cliente que você escolher afetará os requisitos | Besu | + de 800 GB | + de 12 TB | | Erigon | N/D | + de 2,5 TB | -- Nota: Erigon não oferece sincronização rápida, mas a limpeza completa é possível (~ 500 Gb) +- Observação: O Erigon não oferece sincronização rápida, mas permite a remoção completa (~ 500 GB) -Para clientes de consenso, o requisito de espaço também depende da implementação do cliente e dos recursos habilitados (por exemplo, validador slasher), mas geralmente contam com outros 200 Gb necessários para dados de beacon. Com um grande número de validadores, a carga de largura de banda também cresce. Você pode encontrar [detalhes sobre os requisitos do cliente de consenso nesta análise](https://medium.com/@migalabs/analysis-of-ethereum-2-consensus-clients-dfede8e0145e). +Para clientes de consenso, o requisito de espaço também depende da implementação do cliente e dos recursos habilitados (por exemplo, removedor de validador), mas geralmente contam com outros 200 GB necessários para dados do beacon. Com um grande número de validadores, a carga de largura de banda também aumenta. Você pode encontrar [detalhes sobre os requisitos do cliente de consenso nesta análise](https://medium.com/@migalabs/analysis-of-ethereum-2-consensus-clients-dfede8e0145e). #### Soluções "Plug-and-play" {#plug-and-play} @@ -120,72 +110,72 @@ A opção mais fácil para executar um nó com seu próprio hardware é usando f #### Ethereum em um computador de placa única {#ethereum-on-a-single-board-computer} -Uma maneira fácil e barata de executar um nó Ethereum é usar um computador de placa única, mesmo com uma arquitetura ARM como o Raspberry Pi. [Ethereum no ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) fornece imagens fáceis de executar de múltipla execução e cliente de consenso para Raspberry Pi e outras placas ARM. +Uma maneira fácil e barata de executar um nó Ethereum é usar um computador de placa única, mesmo com uma arquitetura ARM como o Raspberry Pi. O [Ethereum no ARM](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) fornece imagens fáceis de executar de múltipla execução e cliente de consenso para Raspberry Pi e outras placas ARM. -Dispositivos pequenos, acessíveis e eficientes como esses são ideais para executar um nó em casa, mas tenha em mente seu desempenho limitado. +Dispositivos pequenos, acessíveis e eficientes como esses são ideais para executar um nó em casa, porém, lembre-se de seu desempenho limitado. ## Executando seu nó {#spinning-up-node} A configuração real do cliente pode ser feita com programas automatizados ou manualmente, configurando o software do cliente diretamente. -Para usuários menos avançados, a abordagem recomendada é usar um programa, software que o orienta na instalação e automatiza o processo de configuração do cliente. No entanto, se você tiver alguma experiência de usar um terminal, as etapas para configuração manual devem ser simples de seguir. +Para usuários menos avançados, a abordagem recomendada é usar um programa, ou seja, um software que orienta você durante a instalação e automatiza o processo de configuração do cliente. No entanto, se você tiver alguma experiência em usar um terminal, as etapas da configuração manual deverão ser simples de seguir. ### Guia de configuração {#automatized-setup} -Vários projetos de fácil utilização visam melhorar a experiência de configuração de um cliente. Esses programas fornecem instalação e configuração automática de cliente, com alguns até oferecendo uma interface gráfica para configuração guiada e monitoramento de clientes. +Vários projetos de fácil utilização visam melhorar a experiência de configuração de um cliente. Esses programas fornecem instalação e configuração automáticas de cliente, com alguns até oferecendo uma interface gráfica para configuração guiada e monitoramento de clientes. -Abaixo estão alguns projetos que podem ajudá-lo a instalar e controlar clientes apenas com alguns cliques: +Abaixo estão alguns projetos que podem ajudar você a instalar e controlar clientes com apenas alguns cliques: -- [DappNode](https://docs.dappnode.io/user/quick-start/first-steps/) – O DappNode não vem apenas com o computador de um fornecedor. O software, o programa atual e o centro de controle com muitos recursos podem ser usados em hardware arbitrário. -- [eth-docker](https://eth-docker.net/) – Configuração automatizada usando Docker, focada em participação fácil e segura. Requer conhecimento básico de terminal e Docker, recomendada para usuários um pouco mais avançados. -- [Stereum](https://stereum.net/ethereum-node-setup/) – Inicialização para instalar clientes em um servidor remoto via conexão SSH com um guia de configuração GUI, centro de controle e muitas outras funcionalidades. -- [NiceNode](https://www.nicenode.xyz/) – Programa com uma experiência de usuário simples para executar um nó em seu computador. Basta escolher os clientes e iniciá-los com alguns cliques. Ainda em desenvolvimento. -- [Sedge](https://docs.sedge.nethermind.io/docs/intro) - Ferramenta de configuração do nó que gera automaticamente uma configuração do Docker usando o assistente de CLI. Escrito em Go pela Nethermind. +- [DappNode](https://docs.dappnode.io/user/quick-start/first-steps/) — O DappNode não vem apenas com o computador de um fornecedor. O software, o verdadeiro inicializador de nós e o centro de controle com muitos recursos podem ser usados em hardwares aleatórios. +- [eth-docker](https://eth-docker.net/) — Configuração automatizada usando o Docker, focada em participação (staking) fácil e segura. Requer conhecimento básico de terminal e Docker, sendo recomendada para usuários um pouco mais avançados. +- [Stereum](https://stereum.net/ethereum-node-setup/) — Inicializador para instalar clientes em um servidor remoto via conexão SSH com um guia de configuração GUI, centro de controle e muitos outros recursos. +- [NiceNode](https://www.nicenode.xyz/) — Programa com uma experiência de usuário simples para executar um nó em seu computador. Basta escolher os clientes e iniciá-los em alguns cliques. Ainda em desenvolvimento. +- [Sedge](https://docs.sedge.nethermind.io/docs/intro) — Ferramenta de configuração de nós que gera automaticamente uma configuração do Docker usando o assistente da CLI. Escrito em Go pela Nethermind. ### Configuração manual do cliente {#manual-setup} A outra opção é baixar, verificar e configurar o software cliente manualmente. Mesmo que alguns clientes ofereçam uma interface gráfica, uma configuração manual ainda requer habilidades básicas com o terminal, mas oferece muito mais versatilidade. -Conforme explicado anteriormente, configurar seu próprio nó Ethereum exigirá executar um par de clientes de consenso e execução. Alguns clientes podem incluir um cliente leve de outro tipo e sincronizar sem a necessidade de qualquer outro software. No entanto, a verificação sem confiança completa requer ambas as implementações. +Conforme explicado anteriormente, configurar seu próprio nó Ethereum exigirá executar um par de clientes de consenso e execução. Alguns clientes podem incluir um cliente leve de outro tipo e sincronizar sem a necessidade de qualquer outro software. No entanto, a verificação sem confiança completa requer as duas implementações. #### Obtendo o software do cliente {#getting-the-client} -Primeiro, você precisa obter o software de [cliente de execução](/developers/docs/nodes-and-clients/#execution-clients) e de [cliente de consenso](/developers/docs/nodes-and-clients/#consensus-clients) de sua preferência. +Primeiro, você precisa obter o software do [cliente de execução](/developers/docs/nodes-and-clients/#execution-clients) e do [cliente de consenso](/developers/docs/nodes-and-clients/#consensus-clients) de sua preferência. -Você pode simplesmente baixar um aplicativo executável ou um pacote de instalação que se adapte ao seu sistema operacional e arquitetura. Sempre verifique as assinaturas e as somas de verificação dos pacotes baixados. Alguns clientes também oferecem repositórios ou imagens do Docker para instalação e atualizações mais fáceis. Todos os clientes são de código aberto, portanto, você também pode construí-los a partir do código-fonte. Isso é um método mais avançado, mas em alguns casos pode ser necessário. +Você pode simplesmente baixar um aplicativo executável ou um pacote de instalação que se adapte ao seu sistema operacional e à sua arquitetura. Sempre verifique as assinaturas e as somas de verificação dos pacotes baixados. Alguns clientes também oferecem repositórios ou imagens do Docker para instalação e atualizações mais fáceis. Todos os clientes são de código aberto, portanto, você também pode construí-los a partir do código-fonte. Esse método é mais avançado, mas, em alguns casos, pode ser necessário. -Instruções para instalar cada cliente são fornecidas na documentação associada nas listas de clientes acima. +As instruções para instalar cada cliente são fornecidas na documentação associada às listas de clientes acima. -Aqui estão as páginas de lançamento dos clientes, nas quais você pode encontrar seus binários pré-construídos ou instruções sobre instalação: +Aqui estão as páginas de lançamento dos clientes, nas quais você pode encontrar seus binários pré-compilados ou instruções sobre instalação: ##### Clientes de execução - [Besu](https://github.com/hyperledger/besu/releases) -- [Erigon](https://github.com/ledgerwatch/erigon#usage) (não fornece um binário pré-construído, precisa ser compilado) +- [Erigon](https://github.com/ledgerwatch/erigon#usage) (não fornece um binário pré-compilado, precisa ser compilado) - [Geth](https://geth.ethereum.org/downloads/) - [Nethermind](https://downloads.nethermind.io/) -Também vale a pena notar que a diversidade de clientes é um [problema na camada de execução](/developers/docs/nodes-and-clients/client-diversity/#execution-layer). Recomenda-se que os leitores considerem a execução de um cliente de execução minoritário. +Também é relevante observar que a diversidade de clientes é um [problema na camada de execução](/developers/docs/nodes-and-clients/client-diversity/#execution-layer). Recomenda-se que os leitores considerem a execução de um cliente de execução minoritário. ##### Clientes de consenso - [Lighthouse](https://github.com/sigp/lighthouse/releases/latest) -- [Lodestar](https://chainsafe.github.io/lodestar/install/source/) (não fornece um binário pré-construído, apenas uma imagem do Docker ou para ser construído a partir da fonte) +- [Lodestar](https://chainsafe.github.io/lodestar/install/source/) (não fornece um binário pré-compilado, apenas uma imagem do Docker ou para ser compilado a partir da fonte) - [Nimbus](https://github.com/status-im/nimbus-eth2/releases/latest) - [Prysm](https://github.com/prysmaticlabs/prysm/releases/latest) - [Teku](https://github.com/ConsenSys/teku/releases) -A [diversidade de cliente](/developers/docs/nodes-and-clients/client-diversity/) é fundamental para nós de consenso executando validadores. Se a maioria dos validadores está executando a implementação de um único cliente, a segurança da rede está em risco. Portanto, é recomendável considerar a escolha de um cliente minoritário. +A [diversidade de clientes](/developers/docs/nodes-and-clients/client-diversity/) é fundamental para nós de consenso executando validadores. Se a maioria dos validadores está executando a implementação de um único cliente, a segurança da rede está em risco. Portanto, é recomendável considerar a escolha de um cliente minoritário. -[Veja o uso mais recente do cliente de rede](https://clientdiversity.org/) e saiba mais sobre a [diversidade do cliente](/developers/docs/nodes-and-clients/client-diversity). +[Veja o uso mais recente do cliente de rede](https://clientdiversity.org/) e saiba mais sobre a [diversidade de clientes](/developers/docs/nodes-and-clients/client-diversity). ##### Verificando o software -Ao baixar o software da Internet, é recomendável verificar sua integridade. Esta etapa é opcional, mas especialmente com uma peça de infraestrutura crucial como o cliente Ethereum. É importante estar ciente dos possíveis vetores de ataque e evitá-los. Se você baixou um binário pré-construído, você precisa confiar nele e arriscar que um invasor possa trocar o executável por um malicioso. +Ao baixar o software da Internet, é recomendável verificar sua integridade. Essa etapa é opcional, mas, especialmente com uma parte de infraestrutura crucial como o cliente Ethereum, é importante estar ciente dos possíveis vetores de ataque e evitá-los. Se você baixou um binário pré-compilado, você precisa confiar nele e correr o risco de um invasor substituir o executável por um malicioso. -Os desenvolvedores assinam binários liberados com suas chaves PGP para que você possa verificar criptograficamente que está executando exatamente o software que eles criaram. Você só precisa obter as chaves públicas usadas pelos desenvolvedores, que podem ser encontradas nas páginas de lançamento do cliente ou na documentação. Após baixar a versão do cliente e sua assinatura, você pode usar uma implementação PGP, por exemplo. [GnuPG](https://gnupg.org/download/index.html) para verificá-los facilmente. Confira um tutorial sobre como verificar software de código aberto usando `gpg` em [linux](https://www.tecmint.com/verify-pgp-signature-downloaded-software/) ou [Windows/MacOS](https://freedom.press/training/verifying-open-source-software/). +Os desenvolvedores assinam binários lançados com suas chaves PGP para que você possa verificar criptograficamente se está executando exatamente o software que eles criaram. Você só precisa obter as chaves públicas usadas pelos desenvolvedores, que podem ser encontradas nas páginas de lançamento do cliente ou na documentação. Após baixar a versão do cliente e sua assinatura, você pode usar uma implementação PGP, por exemplo, [GnuPG](https://gnupg.org/download/index.html) para verificá-los facilmente. Confira um tutorial sobre como verificar software de código aberto usando `GPG` no [Linux](https://www.tecmint.com/verify-pgp-signature-downloaded-software/) ou [Windows/MacOS](https://freedom.press/training/verifying-open-source-software/). -Outra forma de verificação é garantir que o hash, uma impressão digital criptográfica exclusiva, do software que você baixou corresponde ao fornecido pelos desenvolvedores. Isso é ainda mais fácil do que usar o PGP, e alguns clientes oferecem apenas essa opção. Basta executar a função de hash no software baixado e compará-lo com o da página de lançamento. Por exemplo: +Outra forma de verificação é garantir que o hash, uma impressão digital criptográfica exclusiva do software que você baixou, corresponde ao fornecido pelos desenvolvedores. Isso é ainda mais fácil do que usar o PGP, e alguns clientes oferecem apenas essa opção. Basta executar a função de hash no software baixado e compará-lo com o da página de lançamento. Por exemplo: ``` sha256sum teku-22.6.1.tar.gz @@ -197,9 +187,9 @@ sha256sum teku-22.6.1.tar.gz Depois de instalar, baixar ou compilar o software cliente, você estará pronto para executá-lo. Isso só significa que ele tem de ser executado com a configuração adequada. Os clientes oferecem opções de configuração variadas, que podem habilitar vários recursos. -Vamos começar com opções que podem influenciar significativamente o desempenho do cliente e o uso de dados. [Os modos de sincronização](/developers/docs/nodes-and-clients/#sync-modes) representam diferentes métodos de download e validação de dados da cadeia de blocos. Antes de iniciar o nó, você deve decidir que rede e modo de sincronização deve ser usado. As coisas mais importantes a considerar são o espaço em disco e o tempo de sincronização que o cliente precisará. Preste atenção aos documentos do cliente para determinar qual modo de sincronização é o padrão. Se isso não lhe convêm, escolha outro com base no nível de segurança, nos dados disponíveis e no custo. Além do algoritmo de sincronização, você pode também definir a limpeza de diferentes tipos de dados antigos. A limpeza habilita a exclusão de dados desatualizados, por exemplo, remoção de nós de árvore do estado que são inacessíveis de blocos recentes. +Vamos começar com opções que podem influenciar significativamente o desempenho do cliente e o uso de dados. Os [modos de sincronização](/developers/docs/nodes-and-clients/#sync-modes) representam diferentes métodos de download e validação de dados da blockchain. Antes de iniciar o nó, você deve decidir que rede e modo de sincronização deve ser usado. As coisas mais importantes a considerar são o espaço em disco e o tempo de sincronização de que o cliente precisará. Preste atenção nos documentos do cliente para determinar qual modo de sincronização é o padrão. Se não for adequado para você, escolha outro com base no nível de segurança, nos dados disponíveis e no custo. Além do algoritmo de sincronização, você também pode definir a remoção de diferentes tipos de dados antigos. A limpeza habilita a exclusão de dados desatualizados, por exemplo, a remoção de nós de árvore de estado inacessíveis em blocos recentes. -Outras opções básicas de configuração são, por exemplo, escolher uma rede – Rede principal ou redes de teste, habilitando o ponto de extremidade HTTP para RPC ou WebSockets, etc. Você pode encontrar todos os recursos e opções na documentação do cliente. Várias configurações de cliente podem ser definidas executando o cliente com os marcadores correspondentes diretamente na CLI ou no arquivo de configuração. Cada cliente é um pouco diferente; consulte sempre sua documentação oficial ou a página de ajuda para obter detalhes sobre opções de configuração. +Outras opções básicas de configuração são, por exemplo, escolher uma rede, Mainnet (Rede principal) ou redes de teste, habilitando o ponto de extremidade HTTP para RPC ou WebSockets, etc. Você pode encontrar todos os recursos e opções na documentação do cliente. Várias configurações de cliente podem ser definidas executando o cliente com os marcadores correspondentes diretamente na CLI ou no arquivo de configuração. Cada cliente é um pouco diferente, por isso, sempre consulte a documentação oficial ou a página de ajuda do cliente para obter detalhes sobre as opções de configuração. Para fins de teste, você pode preferir executar um cliente em uma das redes de testes. [Veja a visão geral das redes suportadas](/developers/docs/nodes-and-clients/#execution-clients). @@ -207,7 +197,7 @@ Exemplos de execução de clientes de execução com configuração básica pode #### Iniciando a execução do cliente {#starting-the-execution-client} -Antes de iniciar o software cliente do Ethereum, faça uma última verificação de que seu ambiente está pronto. Por exemplo, verifique se: +Antes de iniciar o software cliente do Ethereum, faça uma última verificação para ter certeza de que seu ambiente está pronto. Por exemplo, verifique se: - Há espaço em disco suficiente, considerando a rede escolhida e o modo de sincronização. - A memória e a CPU não são interrompidas por outros programas. @@ -217,11 +207,11 @@ Antes de iniciar o software cliente do Ethereum, faça uma última verificação Execute seu cliente primeiro em uma rede de testes para garantir que tudo esteja funcionando corretamente. -Você precisa declarar no início alguma configuração de cliente que não seja a padrão. Você pode usar sinalizadores ou o arquivo de configuração para declarar sua configuração preferida. O conjunto de recursos e a sintaxe de configuração de cada cliente diferem. Confira a documentação do seu cliente para ver as especificações. +Ao iniciar, você precisa declarar alguma configuração de cliente que não seja a padrão. Você pode usar sinalizadores ou o arquivo de configuração para declarar sua configuração preferida. O conjunto de recursos e a sintaxe de configuração de cada cliente diferem. Confira a documentação do seu cliente para ver as especificações. -Os clientes de execução e consenso se comunicam por meio de um terminal autenticado especificado na [API Engine](https://github.com/ethereum/execution-apis/tree/main/src/engine). Para se conectar a um cliente de consenso, o cliente de execução deve gerar um [`jwtsecret`](https://jwt.io/) em um caminho conhecido. Por razões de segurança e estabilidade, os clientes devem ser executados na mesma máquina e ambos os clientes devem conhecer esse caminho, pois ele é usado para autenticar uma conexão RPC local entre eles. O cliente de execução também deve definir uma porta de escuta para APIs autenticadas. +Os clientes de execução e consenso se comunicam por meio de um terminal autenticado especificado na [API Engine](https://github.com/ethereum/execution-apis/tree/main/src/engine). Para se conectar a um cliente de consenso, o cliente de execução deve gerar um [`jwtsecret`](https://jwt.io/) em um caminho conhecido. Por razões de segurança e estabilidade, os clientes devem ser executados no mesmo computador e ambos os clientes devem conhecer esse caminho, pois ele é usado para autenticar uma conexão RPC local entre eles. O cliente de execução também deve definir uma porta de escuta para APIs autenticadas. -Esse token é gerado automaticamente pelo software cliente, mas, em alguns casos, você pode precisar fazer isso sozinho. Você pode gerá-lo usando [OpenSSL](https://www.openssl.org/): +Esse token é gerado automaticamente pelo software cliente, mas, em alguns casos, talvez você precise fazer isso sozinho. Você pode gerá-lo usando o [OpenSSL](https://www.openssl.org/): ``` openssl rand -hex 32 > jwtsecret @@ -229,24 +219,24 @@ openssl rand -hex 32 > jwtsecret #### Iniciando a execução do cliente {#running-an-execution-client} -Esta seção guiará você na inicialização dos clientes de execução. Serve apenas como exemplo de configuração básica, que iniciará o cliente com estas configurações: +Esta seção guiará você na inicialização dos clientes de execução. Ela serve apenas como exemplo de configuração básica, que iniciará o cliente com estas configurações: -- Especifica a rede para conectar, rede principal nos nossos exemplos - - Em vez disso, você pode escolher [uma das redes de teste](/developers/docs/networks/) para testes preliminares de sua configuração -- Define o diretório de dados, no qual todos os dados, incluindo a cadeia de blocos, serão armazenados +- Especifica a rede à qual se conectar, a rede principal nos nossos exemplos + - Em vez disso, você pode escolher [uma das redes de teste](/developers/docs/networks/) para fazer um teste preliminar da sua configuração +- Define o diretório de dados, no qual todos os dados, incluindo a blockchain, serão armazenados - Certifique-se de substituir o caminho por um real, por exemplo, apontando para sua unidade externa - Habilita interfaces para comunicação com o cliente - - Incluindo JSON RPC e API Engine para comunicação com o cliente de consenso -- Define o caminho para `jwtsecret` para a API autenticada + - Incluindo o RPC JSON e a API Engine para comunicação com o cliente de consenso +- Define o caminho até `jwtsecret` para a API autenticada - Certifique-se de substituir o caminho de exemplo por um real que possa ser acessado pelos clientes, por exemplo, `/tmp/jwtsecret` -Por favor, tenha em mente que este é apenas um exemplo básico, que todas as outras configurações serão definidas como padrão. Preste atenção na documentação de cada cliente para aprender sobre valores padrão, configurações e funcionalidades. Para mais funcionalidades, por exemplo, para executar validadores, monitoramento, etc., consulte a documentação do cliente específico. +Lembre-se de que este é apenas um exemplo básico, todas as outras configurações serão definidas como padrão. Preste atenção na documentação de cada cliente para saber mais sobre valores padrão, configurações e recursos. Para mais recursos, por exemplo, para executar validadores, monitoramento, etc., consulte a documentação específica do cliente. > Observe que as barras invertidas `\` nos exemplos são apenas para fins de formatação; marcadores de configuração podem ser definidos em uma única linha. ##### Executando o Besu -Este exemplo inicia o Besu na rede priincipal, armazena dados da cadeia de blocos no formato padrão em `/data/ethereum`, habilita o JSON RPC e a Engine RPC para conectar ao cliente de consenso. A API Engine é autenticada com o token `jwtsecret` e somente chamadas de `localhost` são permitidas. +Este exemplo inicia o Besu na rede principal, armazena dados da cadeia de blocos no formato padrão em `/data/ethereum`, habilita o RPC JSON e o RPC Engine para conectar o cliente de consenso. A API Engine é autenticada com o token `jwtsecret` e somente chamadas de `localhost` são permitidas. ``` besu --network=mainnet \ @@ -258,7 +248,7 @@ besu --network=mainnet \ --engine-jwt-secret=/path/to/jwtsecret ``` -O Besu também vem com uma opção de lançador o qual fará uma série de perguntas e gerará o arquivo de configuração. Execute o inicializador interativo usando: +O Besu também vem com uma opção de inicializador, que fará uma série de perguntas e gerará o arquivo de configuração. Execute o inicializador interativo usando: ``` besu --Xlauncher @@ -268,7 +258,7 @@ A [documentação do Besu](https://besu.hyperledger.org/en/latest/HowTo/Get-Star ##### Executando o Erigon -Este exemplo inicia o Erigon na rede principal, armazena dados da cadeia de blocos em `/data/ethereum`, habilita o JSON RPC, define quais namespaces são permitidos e habilita a autenticação, para conectar o cliente de consenso, definido pelo caminho `jwtsecret`. +Este exemplo inicia o Erigon na rede principal, armazena dados da blockchain em `/data/ethereum`, habilita o RPC JSON, define quais namespaces são permitidos e habilita a autenticação para conectar o cliente de consenso, definido pelo caminho `jwtsecret`. ``` erigon --chain mainnet \ @@ -277,11 +267,11 @@ erigon --chain mainnet \ --authrpc.jwtsecret=/path/to/jwtsecret ``` -Erigon, por padrão, executa uma sincronização completa com um HDD de 8 GB, o que resultará em mais de 2TB de dados de arquivo. Verifique se o `datadir` está apontando para o disco com espaço livre suficiente ou olha para o parâmetro `--prune` que pode ajustar diferentes tipos de dados. Verifique o `--help` do Erigon para saber mais. +O Erigon, por padrão, executa uma sincronização completa com um HDD de 8 GB, que resultará em mais de 2 TB de dados de arquivo. Verifique se o `datadir` está apontando para o disco com espaço livre suficiente ou olha para o sinalizador `--prune`, que pode ajustar diferentes tipos de dados. Verifique o `--help` do Erigon para saber mais. ##### Executando o Geth -Este exemplo inicia o Geth na rede principal, armazena os dados da cadeia de blocos em `/data/ethereum`, habilita o JSON RPC e define quais namespaces são permitidos. Ele também habilita a autenticação para conectar o cliente de consenso, que requer o caminho para `jwtsecret` e também a opção que define quais conexões são permitidas, em nosso exemplo apenas de `localhost`. +Este exemplo inicia o Geth na rede principal, armazena os dados da cadeia de blocos em `/data/ethereum`, habilita o RPC JSON e define quais namespaces são permitidos. Ele também habilita a autenticação para conectar o cliente de consenso, que requer o caminho para `jwtsecret` e também a opção que define quais conexões são permitidas, em nosso exemplo apenas no `localhost`. ``` geth --mainnet \ @@ -292,11 +282,11 @@ geth --mainnet \ --authrpc.jwtsecret=/path/to/jwtsecret ``` -Confira a [documentação para todas as opções de configuração](https://geth.ethereum.org/docs/fundamentals/command-line-options) e, saiba mais sobre [como executar Geth com um cliente de consenso](https://geth.ethereum.org/docs/getting-started/consensus-clients). +Confira a [documentação para todas as opções de configuração](https://geth.ethereum.org/docs/fundamentals/command-line-options) e saiba mais sobre [como executar Geth com um cliente de consenso](https://geth.ethereum.org/docs/getting-started/consensus-clients). ##### Executando o Nethermind -O Nethermind oferece várias [opções de instalação](https://docs.nethermind.io/nethermind/first-steps-with-nethermind/getting-started). O pacote vem com vários binários, incluindo um Inicializador com configuração guiada, que ajudará você a criar a configuração interativamente. Como alternativa, você encontra o Executor, que é o próprio executável e pode executá-lo com os sinalizadores de configuração. JSON RPC é habilidado por padrão. +O Nethermind oferece várias [opções de instalação](https://docs.nethermind.io/nethermind/first-steps-with-nethermind/getting-started). O pacote vem com vários binários, incluindo um Inicializador com configuração guiada, que ajudará você a criar a configuração interativamente. Como alternativa, você encontrará o Executor, que é o executável em si, que simplesmente pode ser executado com os sinalizadores de configuração. O RPC JSON é habilitado por padrão. ``` Nethermind.Runner --config mainnet \ @@ -306,15 +296,15 @@ Nethermind.Runner --config mainnet \ Os documentos do Nethermind oferecem um [guia completo](https://docs.nethermind.io/nethermind/first-steps-with-nethermind/running-nethermind-post-merge) sobre como executar o Nethermind com o cliente de consenso. -Um cliente de execução iniciará suas funções principais, pontos de extremidade escolhidos e começará a procurar por pares. Depois de conseguir descobrir os pares, o cliente inicia a sincronização. O cliente de execução vai aguardar uma conexão do cliente de consenso. Os dados atuais da cadeia de blocos estarão disponíveis assim que o cliente for sincronizado com sucesso com o estado atual. +Um cliente de execução iniciará suas funções principais, pontos de extremidade escolhidos e começará a procurar por pares. Após conseguir descobrir os pares, o cliente inicia a sincronização. O cliente de execução aguardará uma conexão do cliente de consenso. Os dados atuais da cadeia de blocos estarão disponíveis assim que o cliente for sincronizado com sucesso com o estado atual. #### Iniciando um cliente de consenso {#starting-the-consensus-client} -O cliente de consenso deve ser iniciado com a configuração de porta correta para estabelecer uma conexão RPC local para o cliente de execução. Os clientes de consenso têm de ser executados com a porta do cliente de execução exposta como argumento de configuração. +O cliente de consenso deve ser iniciado com a configuração de porta correta para estabelecer uma conexão RPC local com o cliente de execução. Os clientes de consenso têm de ser executados com a porta do cliente de execução exposta como argumento de configuração. O cliente de consenso também precisa do caminho para o `jwt-secret` do cliente de execução para autenticar a conexão RPC entre eles. Semelhante aos exemplos de execução acima, cada cliente de consenso tem um parâmetro de configuração que usa o caminho do arquivo do token jwt como argumento. Isso deve ser consistente com o caminho `jwtsecret` fornecido ao cliente de execução. -Se você planeja executar um validador, certifique-se de adicionar um marcador de configuração especificando o endereço Ethereum do destinatário da taxa. Aqui é que as recompensas do ether para o validador se acumulam. Cada cliente de consenso tem uma opção, por exemplo. `--suggested-fee-recipient=0xabcd1`, que recebe um endereço Ethereum como argumento. +Se você planeja executar um validador, certifique-se de adicionar um marcador de configuração especificando o endereço Ethereum do destinatário da taxa. É aí que as recompensas do ether para o validador se acumulam. Cada cliente de consenso tem uma opção, por exemplo, `--suggested-fee-recipient=0xabcd1`, que recebe um endereço Ethereum como argumento. Ao iniciar um Beacon Node em uma rede de testes, você pode economizar um tempo de sincronização significativo usando um ponto de extremidade público para [sincronização de ponto de verificação](https://notes.ethereum.org/@launchpad/checkpoint-sync). @@ -322,7 +312,7 @@ Ao iniciar um Beacon Node em uma rede de testes, você pode economizar um tempo ##### Executando o Lighthouse -Antes de executar o Lighthouse, saiba mais sobre como instalá-lo e configurá-lo no [Livro do Lighthouse](https://lighthouse-book.sigmaprime.io/installation.html). +Antes de executar o Lighthouse, saiba mais sobre como instalá-lo e configurá-lo na [Documentação do Lighthouse](https://lighthouse-book.sigmaprime.io/installation.html). ``` lighthouse beacon_node \ @@ -348,7 +338,7 @@ lodestar beacon \ ##### Executando o Nimbus -Nimbus vem com ambos os clientes de consenso e de execução. Ele pode ser executado em vários dispositivos, até mesmo com poder de computação muito modesto. Após [instalar as dependências e o próprio Nimbus](https://nimbus.guide/quick-start.html), você pode executar seu cliente de consenso: +O Nimbus vem com ambos os clientes de consenso e de execução. Ele pode ser executado em vários dispositivos, até mesmo com um poder de computação bem modesto. Após [instalar as dependências e o próprio Nimbus](https://nimbus.guide/quick-start.html), você pode executar seu cliente de consenso: ``` nimbus_beacon_node \ @@ -360,7 +350,7 @@ nimbus_beacon_node \ ##### Executando o Prysm -O Prysm vem com um script que permite uma fácil instalação automática. Os detalhes podem ser encontrados nos [documentos do Prysm](https://docs.prylabs.network/docs/install/install-with-script). +O Prysm vem com um script que permite uma instalação automática fácil. Os detalhes podem ser encontrados na [documentação do Prysm](https://docs.prylabs.network/docs/install/install-with-script). ``` ./prysm.sh beacon-chain \ @@ -379,27 +369,27 @@ teku --network mainnet \ --ee-jwt-secret-file "/path/to/jwtsecret" ``` -Quando um cliente de consenso se conecta ao cliente de execução para ler o contrato de depósito e identificar validadores, ele também se conecta a outros pares do Beacon Node e começa a sincronizar os espaços de consenso do gênesis. Quando o Beacon Node atinge a época atual, a API do Beacon se torna utilizável para seus validadores. Saiba mais sobre [APIs do Beacon Node](https://eth2docs.vercel.app/). +Quando um cliente de consenso se conecta ao cliente de execução para ler o contrato de depósito e identificar validadores, ele também se conecta a outros pares do Beacon Node e começa a sincronizar os slots de consenso da origem. Quando o Beacon Node atinge a época atual, a API Beacon se torna utilizável para seus validadores. Saiba mais sobre [APIs do Beacon Node](https://eth2docs.vercel.app/). ### Adicionando validadores {#adding-validators} Um cliente de consenso serve como um Beacon Node para os validadores se conectarem. Cada cliente de consenso tem seu próprio software de validador descrito em detalhes em sua respectiva documentação. -Executar seu próprio validador permite a [participação individual](https://ethereum.org/en/staking/solo/), o método mais impactante e confiável para dar suporte à rede Ethereum. No entanto, isso requer um depósito de 32 ETH. Para executar um validador em seu próprio nó com uma quantidade menor, um pool descentralizado com operadores de nós sem permissão, como [Rocket Pool](https://rocketpool.net/node-operators), poderá lhe interessar. +Executar seu próprio validador permite a [participação individual](https://ethereum.org/en/staking/solo/), o método mais impactante e não confiável para dar suporte à rede Ethereum. No entanto, isso requer um depósito de 32 ETH. Para executar um validador em seu próprio nó com uma quantidade menor, um pool descentralizado com operadores de nós sem permissão, como [Rocket Pool](https://rocketpool.net/node-operators), poderá ser interessante. -A maneira mais fácil de começar com a participação e a geração de chaves de validação é usar a [Plataforma de lançamento de participação da rede de testes Goerli](https://goerli.launchpad.ethereum.org/), que permite testar sua configuração [executando nós no Goerli](https://notes.ethereum.org/@launchpad/goerli). Quando você estiver pronto para a Rede principal, você poderá repetir essas etapas usando a [Plataforma de lançamento de participação da rede de testes Goerli](https://launchpad.ethereum.org/). +A maneira mais fácil de começar com a participação e a geração de chaves de validação é usar a [Plataforma de lançamento de participação da rede de testes Goerli](https://goerli.launchpad.ethereum.org/), que permite testar sua configuração [executando nós no Goerli](https://notes.ethereum.org/@launchpad/goerli). Quando você estiver pronto para a Mainnet (Rede principal), você poderá repetir essas etapas usando a [Plataforma de lançamento de participação da Mainnet](https://launchpad.ethereum.org/). -Consulte a [página de participação](/staking) para obter uma visão geral sobre as opções de participação. +Consulte a [página de staking (participação)](/staking) para obter uma visão geral sobre as opções de participação. ### Usando o nó {#using-the-node} Os clientes de execução oferecem [pontos de extremidade da API RPC](/developers/docs/apis/json-rpc/) que você pode usar para enviar transações, interagir ou implantar contratos inteligentes na rede Ethereum de várias maneiras: - Chamando-os manualmente com um protocolo adequado (por exemplo, usando `curl`) -- Anexando um console (exemplo `geth attach`) -- Implementá-los em aplicações usando bibliotecas do Web3, por exemplo, [web3.py](https://web3py.readthedocs.io/en/stable/overview.html#overview), [ethers](https://github.com/ethers-io/ethers.js/) +- Anexando um console (por exemplo, `geth attach`) +- Implementá-los em aplicações usando bibliotecas da Web3, por exemplo, [web3.py](https://web3py.readthedocs.io/en/stable/overview.html#overview), [ethers](https://github.com/ethers-io/ethers.js/) -Diferentes clientes têm diferentes implementações dos pontos de extremidade RPC. Mas existe um JSON-RPC padrão que você pode usar com cada cliente. Para uma visão geral [leia os documentos JSON-RPC](/developers/docs/apis/json-rpc/). Aplicativos que precisam de informações da rede Ethereum podem usar esse RPC. Por exemplo, a popular carteira MetaMask permite você [conectar-se ao seu próprio endpoint RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node), que tem fortes benefícios de privacidade e segurança. +Diferentes clientes têm diferentes implementações dos pontos de extremidade RPC. Porém, existe um JSON-RPC padrão que você pode usar com cada cliente. Para obter uma visão geral, [leia a documentação sobre JSON-RPC](/developers/docs/apis/json-rpc/). Os aplicativos que precisam de informações da rede Ethereum podem usar esse RPC. Por exemplo, a popular carteira MetaMask permite que você [se conecte ao seu próprio ponto de extremidade RPC](https://metamask.zendesk.com/hc/en-us/articles/360015290012-Using-a-Local-Node), que conta com grandes benefícios de privacidade e segurança. Todos os clientes de consenso expõem uma [API Beacon](https://ethereum.github.io/beacon-APIs), que pode ser usada para verificar o status do cliente de consenso ou baixar blocos e dados de consenso enviando solicitações usando ferramentas como [Curl](https://curl.se). Mais informações sobre isso podem ser encontradas na documentação de cada cliente de consenso. @@ -407,69 +397,69 @@ Todos os clientes de consenso expõem uma [API Beacon](https://ethereum.github.i A porta padrão para o cliente de execução JSON-RPC é `8545`, mas você pode modificar as portas dos pontos de extremidade locais na configuração. Por padrão, a interface RPC só pode ser acessada no host local do seu computador. Para torná-lo acessível remotamente, você pode expô-lo ao público alterando o endereço para `0.0.0.0`. Isso o tornará acessível pela rede local e endereços IP públicos. Na maioria dos casos, você também precisará configurar o encaminhamento de porta no seu roteador. -Aborde a exposição de portas à Internet com cuidado, pois isso permitirá que qualquer pessoa na Internet controle seu nó. Atores maliciosos podem acessar seu nó para derrubar seu sistema ou roubar seus fundos, se você estiver usando seu cliente como uma carteira. +Tenha cuidado ao expor as portas à Internet, pois isso permitirá que qualquer pessoa na Internet controle seu nó. Atores maliciosos poderão acessar seu nó para derrubar seu sistema ou roubar seus fundos se você estiver usando seu cliente como uma carteira. -Uma forma de contornar isso é evitar que métodos RPC potencialmente nocivos sejam modificáveis. Por exemplo, com Geth, você pode declarar métodos modificáveis com uma configuração: `--http.api web3,eth,txpool`. +Uma forma de contornar isso é evitar que métodos RPC potencialmente nocivos sejam modificáveis. Por exemplo, com o Geth, você pode declarar métodos modificáveis com um sinalizador: `--http.api web3,eth,txpool`. -O acesso à interface RPC pode ser estendido por meio do desenvolvimento de APIs da camada de fronteira ou aplicativos de servidor Web, como o Nginx, e conectando-os ao endereço e porta local do seu cliente. O aproveitamento de uma camada intermediária também pode permitir que os desenvolvedores configurem um certificado para conexões seguras `https` para a interface RPC. +O acesso à interface RPC pode ser estendido por meio do desenvolvimento de APIs da camada de borda ou aplicativos de servidor Web, como o Nginx, e conectando-os ao endereço e porta locais do seu cliente. A utilização de uma camada intermediária também pode permitir que os desenvolvedores configurem um certificado para conexões `https` seguras na interface RPC. -Configurar um servidor Web, um proxy ou face a uma API Rest externa não é a única maneira de fornecer acesso ao ponto de extremidade RPC do seu nó. Outra maneira de preservar a privacidade para configurar um ponto de extremidade publicamente acessível é hospedar o nó em seu próprio serviço onion [Tor](https://www.torproject.org/). Isso permitirá que você se comunique com o RPC fora da sua rede local sem um endereço público estático de IP ou portas abertas. No entanto, usar esta configuração só pode permitir que o ponto de extremidade RPC seja acessível através da rede Tor, que não é suportada por todos os aplicativos e pode resultar em problemas de conexão. +Configurar um servidor Web, um proxy ou uma API Rest externa não é a única maneira de fornecer acesso ao ponto de extremidade RPC do seu nó. Outra maneira de preservar a privacidade para configurar um ponto de extremidade publicamente acessível é hospedar o nó em seu próprio serviço onion da rede [Tor](https://www.torproject.org/). Isso permitirá que você se comunique com o RPC fora da sua rede local sem um endereço público estático de IP ou portas abertas. No entanto, usar essa configuração só permitirá que o ponto de extremidade RPC seja acessível pela da rede Tor, que não é suportada por todos os aplicativos e poderá resultar em problemas de conexão. -Para fazer isso, você precisa criar seu próprio [serviço onion](https://community.torproject.org/onion-services/). Confira [a documentação](https://community.torproject.org/onion-services/setup/) sobre a configuração do serviço onion para hospedar o seu próprio. Você pode apontá-lo para um servidor Web com proxy para a porta RPC ou apenas diretamente para o RPC. +Para fazer isso, você precisa criar seu próprio [serviço onion](https://community.torproject.org/onion-services/). Confira [a documentação](https://community.torproject.org/onion-services/setup/) sobre a configuração do serviço onion para hospedar o seu próprio serviço. Você pode direcioná-lo para um servidor Web com proxy para a porta RPC ou apenas diretamente para o RPC. -Por fim, e uma das formas mais populares de fornecer acesso a redes internas é através de uma conexão VPN. Dependendo do seu caso de uso e da quantidade de usuários que precisam de acesso ao seu nó, uma conexão VPN segura pode ser uma opção. [OpenVPN](https://openvpn.net/) é uma VPN SSL completa que implementa a extensão de rede segura da camada OSI 2 ou 3 usando o protocolo SSL/TLS padrão da indústria, suporta métodos flexíveis de autenticação de cliente com base em certificados, cartões inteligentes e/ou credenciais de usuário/senha e permite políticas de controle de acesso específicas de usuário ou grupo usando regras de firewall aplicadas à interface virtual VPN. +Por fim, e uma das formas mais populares de fornecer acesso a redes internas, é por meio de uma conexão VPN. Dependendo do seu caso de uso e da quantidade de usuários que precisam de acesso ao seu nó, uma conexão VPN segura pode ser uma opção. [OpenVPN](https://openvpn.net/) é uma VPN SSL completa que implementa a extensão de rede segura da camada OSI 2 ou 3 usando o protocolo SSL/TLS padrão da indústria, dá suporte a métodos flexíveis de autenticação de cliente com base em certificados, cartões inteligentes e/ou credenciais de usuário/senha e permite políticas de controle de acesso específicas de usuário ou grupo usando regras de firewall aplicadas à interface virtual VPN. ### Operando o nó {#operating-the-node} -Você deve monitorar regularmente seu nó para garantir que ele esteja funcionando corretamente. Você pode precisar fazer manutenção ocasional. +Você deve monitorar regularmente seu nó para garantir que ele esteja funcionando corretamente. Talvez seja necessário realizar manutenções ocasionais. #### Mantendo o nó online {#keeping-node-online} -Seu nó não precisa estar online o tempo todo, mas você deve mantê-lo online o máximo possível para mantê-lo sincronizado com a rede. Você pode desligar ele para reiniciá-lo, mas lembre-se de que: +Seu nó não precisa estar online o tempo todo, mas você deve mantê-lo online o máximo possível para mantê-lo sincronizado com a rede. Você pode desligá-lo para reiniciá-lo, mas lembre-se de que: - O encerramento pode levar alguns minutos se o estado recente ainda estiver sendo gravado no disco. - Encerramentos forçados podem danificar o banco de dados, exigindo que você ressincronize todo o nó. -- Seu cliente ficará dessincronizado com a rede e precisará ser ressincronizado quando você o reiniciar. Embora o nó possa começar a sincronizar de onde foi o último encerramento, o processo pode demorar dependendo de quanto tempo ele esteve offline. +- Seu cliente ficará dessincronizado com a rede e precisará ser ressincronizado quando você o reiniciar. Embora o nó possa começar a sincronizar a partir do ponto do último encerramento, o processo pode demorar dependendo de quanto tempo ele esteve offline. -_Isso não se aplica a nós validadores da camada de consenso._ Colocar seu nó offline afetará todos os serviços dependentes dele. Se você estiver rodando um nó para fins de _participação_, então você deve tentar minimizar o tempo de inatividade tanto quanto for possível. +_Isso não se aplica a nós validadores da camada de consenso._ Colocar seu nó offline afetará todos os serviços dependentes dele. Se você estiver rodando um nó para fins de _staking (participação)_, você deve tentar minimizar o tempo de inatividade tanto quanto possível. #### Criando serviços de clientes {#creating-client-services} -Considere criar um serviço para executar seus clientes automaticamente na inicialização. Por exemplo, em servidores Linux, uma boa prática seria criar um serviço, por exemplo, com `systemd`, que executa o cliente com a configuração adequada, sob um usuário com privilégios limitados e reinicia automaticamente. +Considere criar um serviço para executar seus clientes automaticamente na inicialização. Por exemplo, em servidores Linux, a boa prática seria criar um serviço, por exemplo, com `systemd`, que executa o cliente com a configuração adequada em um usuário com privilégios limitados, e reiniciar automaticamente. #### Atualizando clientes {#updating-clients} -Você precisa manter seu software cliente atualizado com os mais recentes patches de segurança, recursos e [EIPs](/eips/). Especialmente antes de [bifurcações permanentes](/history/), verifique se você está executando as versões corretas do cliente. +Você precisa manter seu software cliente atualizado com os patches de segurança, recursos e [EIPs](/eips/) mais recentes. Sobretudo antes das [bifurcações permanentes](/history/), verifique se você está executando as versões corretas do cliente. > Antes de atualizações importantes da rede, a EF publica uma postagem em seu [blog](https://blog.ethereum.org). Você pode [assinar esses anúncios](https://groups.google.com/a/ethereum.org/g/announcements) para receber uma notificação no seu e-mail quando o seu nó precisar de uma atualização. Atualizar clientes é muito simples. Cada cliente tem instruções específicas em sua documentação, mas o processo geralmente é apenas baixar a versão mais recente e reiniciar o cliente com o novo executável. O cliente deve continuar de onde parou, mas com as atualizações aplicadas. -Cada implementação de cliente tem uma cadeia de caracteres de versão legível por humanos usada no protocolo ponto a ponto, mas também é acessível a partir da linha de comando. Essa cadeia de caracteres de versão permite que os usuários verifiquem se estão executando a versão correta e possibilita exploradores de blocos e outras ferramentas analíticas interessadas em quantificar a distribuição de clientes específicos na rede. Consulte a documentação do cliente individual para obter mais informações sobre cadeias de caracteres de versão. +Cada implementação de cliente tem uma cadeia de caracteres de versão legível por humanos usada no protocolo ponto a ponto, mas também é acessível a partir da linha de comando. Essa cadeia de caracteres de versão permite que os usuários verifiquem se estão executando a versão correta e possibilita exploradores de blocos e outras ferramentas analíticas interessadas em quantificar a distribuição de clientes específicos na rede. Consulte a documentação de cada cliente para obter mais informações sobre cadeias de caracteres de versão. #### Executando serviços adicionais {#running-additional-services} -Executar seu próprio nó permite que você use serviços que exigem acesso direto ao cliente RPC do Ethereum. Estes são serviços construídos em cima do Ethereum, como [soluções de camada 2](/developers/docs/scaling/#layer-2-scaling), back-end para carteiras, exploradores de blocos, ferramentas de desenvolvimento e outras infraestruturas Ethereum. +Executar seu próprio nó permite que você use serviços que exigem acesso direto ao cliente RPC do Ethereum. Estes são serviços construídos em cima do Ethereum, como [soluções de camada 2](/developers/docs/scaling/#layer-2-scaling), back-end para carteiras, exploradores de blocos, ferramentas de desenvolvimento e outras infraestruturas do Ethereum. #### Monitorando o nó {#monitoring-the-node} -Para monitorar adequadamente seu nó, considere coletar métricas. Os clientes fornecem pontos de extremidade de métricas para que você possa obter dados abrangentes sobre seu nó. Use ferramentas como [InfluxDB](https://www.influxdata.com/get-influxdb/) ou [Prometheus](https://prometheus.io/) para criar bancos de dados que você pode transformar em visualizações e gráficos em softwares como [Grafana](https://grafana.com/). Existem muitas configurações para usar este software e diferentes painéis do Grafana para você visualizar seu nó e a rede como um todo. Por exemplo, confira [tutorial sobre como monitorar o Geth](/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/). +Para monitorar seu nó corretamente, considere coletar métricas. Os clientes fornecem pontos de extremidade de métricas para que você possa obter dados abrangentes sobre seu nó. Use ferramentas como [InfluxDB](https://www.influxdata.com/get-influxdb/) ou [Prometheus](https://prometheus.io/) para criar bancos de dados que você pode transformar em visualizações e gráficos em softwares como o [Grafana](https://grafana.com/). Existem muitas configurações para usar esse software e diferentes painéis do Grafana para você visualizar seu nó e a rede como um todo. Por exemplo, confira o [tutorial sobre como monitorar o Geth](/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/). -Como parte de seu monitoramento, certifique-se de ficar de olho no desempenho de sua máquina. Durante a sincronização inicial do seu nó, o software cliente pode sobrecarregar muito a CPU e a RAM. Além do Grafana, você pode usar as ferramentas que seu sistema operacional oferece, como `htop` ou `uptime` para fazer isso. +Como parte do seu monitoramento, fique de olho no desempenho do seu computador. Durante a sincronização inicial do seu nó, o software cliente pode sobrecarregar muito a CPU e a memória RAM. Para fazer isso, além do Grafana, você pode usar as ferramentas que seu sistema operacional oferece, como `htop` ou `uptime`. ## Leitura adicional {#further-reading} -- [Guias de participação do Ethereum](https://github.com/SomerEsat/ethereum-staking-guides) - _Somer Esat, atualizado com frequência_ -- [Guia | Como configurar um validador para participação do Ethereum na rede principal](https://www.coincashew.com/coins/overview-eth/guide-or-how-to-setup-a-validator-on-eth2-mainnet) _– CoinCashew, atualizado regularmente_ -- [Guias do ETHStaker sobre como executar validadores em redes de teste](https://github.com/remyroy/ethstaker#guides) – _ETHStaker, atualizado regularmente_ +- [Guias de participação do Ethereum](https://github.com/SomerEsat/ethereum-staking-guides) — _Somer Esat, atualizado regularmente_ +- [Guia | Como configurar um validador para participação do Ethereum na rede principal](https://www.coincashew.com/coins/overview-eth/guide-or-how-to-setup-a-validator-on-eth2-mainnet) _— CoinCashew, atualizado regularmente_ +- [Guias do ETHStaker sobre como executar validadores em redes de teste](https://github.com/remyroy/ethstaker#guides) — _ETHStaker, atualizado regularmente_ - [Perguntas frequentes sobre o The Merge para operadores de nós](https://notes.ethereum.org/@launchpad/node-faq-merge) — _julho de 2022_ -- [Analisando os requisitos de hardware para ser um nó totalmente validado no Ethereum](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _ – Albert Palau, 24 de setembro de 2018_ -- [Executando nós completos do Ethereum: um guia para os pouco motivados](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _– Justin Leroux, 7 de novembro de 2019_ -- [Executando um nó do Hyperledger Besu na Mainnet do Ethereum: benefícios, requisitos e configurações](https://pegasys.tech/running-a-hyperledger-besu-node-on-the-ethereum-mainnet-benefits-requirements-and-setup/) _– Felipe Faraggi, 7 de maio de 2020_ -- [Implantando o cliente Nethermind do Ethereum com uma pilha de monitoramento](https://medium.com/nethermind-eth/deploying-nethermind-ethereum-client-with-monitoring-stack-55ce1622edbd) _– Nethermind.eth, 8 de julho de 2020_ +- [Analisando os requisitos de hardware para tornar um nó totalmente validado no Ethereum](https://medium.com/coinmonks/analyzing-the-hardware-requirements-to-be-an-ethereum-full-validated-node-dc064f167902) _– Albert Palau, 24 de setembro de 2018_ +- [Executando nós completos do Ethereum: um guia para os pouco motivados](https://medium.com/@JustinMLeroux/running-ethereum-full-nodes-a-guide-for-the-barely-motivated-a8a13e7a0d31) _— Justin Leroux, 7 de novembro de 2019_ +- [Executando um nó do Hyperledger Besu na Mainnet (Rede principal) do Ethereum: benefícios, requisitos e configurações](https://pegasys.tech/running-a-hyperledger-besu-node-on-the-ethereum-mainnet-benefits-requirements-and-setup/) _— Felipe Faraggi, 7 de maio de 2020_ +- [Implantando o cliente Nethermind do Ethereum com uma pilha de monitoramento](https://medium.com/nethermind-eth/deploying-nethermind-ethereum-client-with-monitoring-stack-55ce1622edbd) _— Nethermind.eth, 8 de julho de 2020_ ## Tópicos relacionados {#related-topics} -- [Nós e clientes](/developers/docs/nodes-and-clients/) +- [ Nós e clientes](/developers/docs/nodes-and-clients/) - [Blocos](/developers/docs/blocks/) - [Redes](/developers/docs/networks/) diff --git a/src/content/translations/pt-br/developers/docs/oracles/index.md b/src/content/translations/pt-br/developers/docs/oracles/index.md index af6007479c4..70fbd660868 100644 --- a/src/content/translations/pt-br/developers/docs/oracles/index.md +++ b/src/content/translations/pt-br/developers/docs/oracles/index.md @@ -304,7 +304,7 @@ Também é possível que os oráculos baseados em stake consigam cortar operador Oráculos descentralizados implementam vários designs de incentivo para evitar o comportamento [bizantino](https://en.wikipedia.org/wiki/Byzantine_fault) entre os nós oráculos. Especificamente, eles alcançam a _atribuibilidade_ e _responsabilidade_: -1. Nós oráculos descentralizados são frequentemente obrigados a assinar os dados que eles fornecem em resposta a solicitações de dados. Essa informação ajuda a avaliar o desempenho histórico de nós oráculos, para que os usuários possam filtrar nós oráculos não confiáveis ao fazer solicitações de dados. Um exemplo é o [Oracle Reputation](https://oracle.reputation.link/) da Chainlink ou o [Sistema de Reputação Algoritmica](https://docs.witnet.io/intro/about/architecture#algorithmic-reputation-system) da Witnet. +1. Nós oráculos descentralizados são frequentemente obrigados a assinar os dados que eles fornecem em resposta a solicitações de dados. Essa informação ajuda a avaliar o desempenho histórico de nós oráculos, para que os usuários possam filtrar nós oráculos não confiáveis ao fazer solicitações de dados. Um exemplo é o [Sistema de Reputação de Algoritmos](https://docs.witnet.io/intro/about/architecture#algorithmic-reputation-system) da Witnet. 2. Os oráculos descentralizados, conforme explicado anteriormente, podem exigir que os nós façam stake confiando somente na verdade dos dados que eles submetem. Se a reivindicação é confirmada, esse staking pode ser restituído juntamente com recompensas por um serviço honesto. Mas também pode ser reduzido no caso de a informação ser incorreta, o que impões certa responsabilização. @@ -361,7 +361,7 @@ contract PriceConsumerV3 { Certas aplicações da blockchain, como jogos baseados em blockchain ou esquemas de loteria, requerem um alto nível de imprevisibilidade e aleatoriedade para funcionar efetivamente. No entanto, a execução determinística de blockchains elimina qualquer fonte de aleatoriedade. -A abordagem habitual é usar funções criptográficas pseudoaleatórias, como o `blockhash`, mas isso é passível de [manipulação por outros atores](https://ethereum.stackexchange.com/questions/3140/risk-of-using-blockhash-other-miners-preventing-attack#:~:text=So%20while%20the%20miners%20can,to%20one%20of%20the%20players.), nomeadamente mineradores resolvendo o algoritmo de prova de trabalho. Além disso, a [troca para a prova de participação](/roadmap/merge/) do Ethereum significa que os desenvolvedores não podem mais confiar em `blockhash` para aleatoriedade on-chain (entretanto, o [mecanismo RANDAO](https://eth2book.info/altair/part2/building_blocks/randomness) da Beacon Chain fornece uma fonte alternativa de aleatoriedade). +A abordagem habitual é usar funções criptográficas pseudoaleatórias, como o `blockhash`, mas isso é passível de [manipulação por outros atores](https://ethereum.stackexchange.com/questions/3140/risk-of-using-blockhash-other-miners-preventing-attack#:~:text=So%20while%20the%20miners%20can,to%20one%20of%20the%20players.), nomeadamente mineradores resolvendo o algoritmo de prova de trabalho. Além disso, a [mudança para a prova de participação](/roadmap/merge/) do Ethereum significa que os desenvolvedores não podem mais confiar em `blockhash` para obter aleatoriedade on-chain (no entanto, o [mecanismo RANDAO](https://eth2book.info/altair/part2/building_blocks/randomness) da Beacon Chain fornece uma fonte alternativa de aleatoriedade). É possível gerar o valor aleatório off-chain e enviá-lo on-chain, mas fazer isso impõe requisitos de confiança elevados aos usuários. Eles devem acreditar que o valor foi verdadeiramente gerado através de mecanismos imprevisíveis e não foi alterado em trânsito. @@ -383,7 +383,7 @@ Os desenvolvedores precisarão acionar essas funções em intervalos para manter Algumas redes descentralizadas de oráculos oferecem serviços de automação, que permitem que nós de oráculos off-chain acionem funções de contrato inteligente de acordo com parâmetros definidos pelo usuário. Normalmente, isso requer "registrar" o contrato-alvo com o serviço oráculo, fornecendo fundos para pagar o operador do oráculo, e especificar as condições ou horários para disparar o contrato. -Um exemplo é a [Keeper Network](https://chain.link/keepers) da rede Chainlink, que fornece opções para que os contratos inteligentes terceirizem tarefas de manutenção regulares de maneira minimizada e descentralizada. Leia a [documentação oficial da Keepers](https://docs.chain.link/docs/chainlink-keepers/introduction/) para obter informações sobre como tornar o seu contrato compatível com Keeper e usar o serviço UpKeep. +Um exemplo é a [Keeper Network](https://chain.link/keepers) da rede Chainlink, que fornece opções para que os contratos inteligentes terceirizem tarefas de manutenção regulares de maneira minimizada e descentralizada. Leia a [documentação oficial do Keeper](https://docs.chain.link/docs/chainlink-keepers/introduction/) para obter informações sobre como tornar seu contrato compatível com o Keeper e usar o serviço Upkeep. ## Usar oráculos da blockchain {#use-blockchain-oracles} @@ -399,13 +399,9 @@ Existem vários aplicativos de oráculos que você pode integrar no seu dapp Eth **[Band Protocol](https://bandprotocol.com/)**: _Band Protocol é uma plataforma de dados de oráculos cross-chain que agrega e conecta dados do mundo real e APIs a contratos inteligentes._ -**[Provable](https://provable.xyz/)**: _conecta dapps de blockchain com qualquer Web API externa e aproveita provas TLSNotary, ambientes de execução confiáveis (TEEs) e primitivos criptográficos seguros para garantir a autenticidade dos dados._ +**[Paralink](https://paralink.network/)** — _ o Paralink fornece uma plataforma de código aberto e descentralizada de oráculos para contratos inteligentes em execução no Ethereum e em outras blockchains populares._ -**[Paralink](https://paralink.network/)**: _Paralink fornece uma plataforma de código aberto e descentralizada de oráculos para contratos inteligentes em execução no Ethereum e em outras blockchains populares._ - -**[Dos.Network](https://dos.network/)**: _é uma rede de serviços de oráculos descentralizada para impulsionar a usabilidade da blockchain com dados do mundo real e poder de computação._ - -**[Rede Pyth](https://pyth.network/)** – _A rede Pyth é uma rede de oráculos financeiros internos projetada para publicar dados contínuos do mundo real em cadeia em um ambiente autossustentável, descentralizado e inviolável._ +**[Rede Pyth](https://pyth.network/)** — _A rede Pyth é uma rede de oráculos financeiros internos projetada para publicar dados contínuos do mundo real em cadeia em um ambiente autossustentável, descentralizado e inviolável._ ## Leitura Adicional {#further-reading} diff --git a/src/content/translations/pt-br/developers/docs/programming-languages/java/index.md b/src/content/translations/pt-br/developers/docs/programming-languages/java/index.md index 566d22db032..d0b7261128c 100644 --- a/src/content/translations/pt-br/developers/docs/programming-languages/java/index.md +++ b/src/content/translations/pt-br/developers/docs/programming-languages/java/index.md @@ -22,7 +22,7 @@ Precisa de uma introdução geral? Confira [ethereum.org/learn](/learn/) ou [eth ## Trabalhando com clientes Ethereum {#working-with-ethereum-clients} -Aprenda como usar [Web3J](https://github.com/web3j/web3j) e Besu Hiperregistro, dois principais clientes Java Ethereum +Aprenda como usar [Web3J](https://github.com/web3j/web3j)e Besu Hiperregistro, dois principais clientes Java Ethereum - [Conectando a um cliente Ethereum com Java, Eclipse e Web3J](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j) - [Gerenciando uma conta Ethereum com Java e Web3j](https://kauri.io/article/925d923e12c543da9a0a3e617be963b4/manage-an-ethereum-account-with-java-and-web3j) diff --git a/src/content/translations/pt-br/developers/docs/programming-languages/javascript/index.md b/src/content/translations/pt-br/developers/docs/programming-languages/javascript/index.md index ded637ad7e3..531cd8efdd0 100644 --- a/src/content/translations/pt-br/developers/docs/programming-languages/javascript/index.md +++ b/src/content/translations/pt-br/developers/docs/programming-languages/javascript/index.md @@ -19,7 +19,7 @@ Você pode usar essas bibliotecas para interagir com contratos inteligentes na E **Confira** - [Web3.js](https://web3js.readthedocs.io/) -- [Ethers.js - \_\_Implementação completa de uma carteira Ethereum e utilidades em JavaScript e TypeScript.](https://docs.ethers.io/) +- [Ethers.js - Implementação completa de uma carteira Ethereum e utilidades em JavaScript e TypeScript.](https://docs.ethers.io/) ### Smart Contracts {#smart-contracts} diff --git a/src/content/translations/pt-br/developers/docs/programming-languages/python/index.md b/src/content/translations/pt-br/developers/docs/programming-languages/python/index.md index 1d216cca577..d908c4949b4 100644 --- a/src/content/translations/pt-br/developers/docs/programming-languages/python/index.md +++ b/src/content/translations/pt-br/developers/docs/programming-languages/python/index.md @@ -50,16 +50,16 @@ Precisa de uma introdução geral? Confira [ethereum.org/learn](/learn/) ou [eth - [Web3.py](https://github.com/ethereum/web3.py) - _Biblioteca em Python para interagir com Ethereum_ - [Vyper](https://github.com/ethereum/vyper/) - _Linguagem de Smart Contract em Python para a Máquina Virtual Ethereum_ -- [Ape](https://github.com/ApeWorX/ape) _– A ferramenta de desenvolvimento de contrato inteligente (smart contract) para Pythonistas, Cientistas de Dados e Profissionais de Segurança_ -- [Brownie](https://github.com/eth-brownie/brownie) _– Framework em Python para implantar, testar e interagir com contratos inteligentes Ethereum_ -- [py-evm](https://github.com/ethereum/py-evm) _– Implementação de uma Máquina Virtual Ethereum_ -- [eth-tester](https://github.com/ethereum/eth-tester) _– ferramentas para testar aplicativos baseados na Ethereum_ -- [eth-utils](https://github.com/ethereum/eth-utils/) _– funções de utilidade para trabalhar com bases de código relacionadas com a Ethereum_ -- [py-solc-x](https://pypi.org/project/py-solc-x/) _– wrapper em Python em cima do compilador solc solidity com suporte à versão 0.5.x_ -- [py-wasm](https://github.com/ethereum/py-wasm) _– implementação em Python de um intérprete de montagem web_ -- [pydevp2p](https://github.com/ethereum/pydevp2p) _– Implementação de uma pilha P2P Ethereum_ -- [pymaker](https://github.com/makerdao/pymaker) _– API em Python para contratos Maker_ -- [siwe](https://github.com/spruceid/siwe-py) _– Registre-se com Ethereum (siwe) para Python_ +- [Ape](https://github.com/ApeWorX/ape) - _A ferramenta de desenvolvimento de contrato inteligente (smart contract) para Pythonistas, Cientistas de Dados e Profissionais de Segurança_ +- [Brownie](https://github.com/eth-brownie/brownie) - _Framework em Python para implantar, testar e interagir com contratos inteligentes Ethereum_ +- [py-evm](https://github.com/ethereum/py-evm) - _Implementação de uma Máquina Virtual Ethereum_ +- [eth-tester](https://github.com/ethereum/eth-tester) - _ferramentas para testar aplicativos baseados na Ethereum_ +- [eth-utils](https://github.com/ethereum/eth-utils/) - _funções de utilidade para trabalhar com bases de código relacionadas com a Ethereum_ +- [py-solc-x](https://pypi.org/project/py-solc-x/) - _wrapper em Python em cima do compilador solc solidity com suporte à versão 0.5._ +- [py-wasm](https://github.com/ethereum/py-wasm) - _implementação em Python de um intérprete de montagem web_ +- [pydevp2p](https://github.com/ethereum/pydevp2p) - _Implementação de uma pilha P2P Ethereum_ +- [pymaker](https://github.com/makerdao/pymaker) - _API em Python para contratos Maker_ +- [siwe](https://github.com/spruceid/siwe-py) - _Registre-se com Ethereum (siwe) para Python_ - [Web3 DeFi para integrações Ethereum](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _Um pacote Python com integrações prontas para ERC-20, Uniswap e outros projetos populares_ ### Arquivado / Não mais mantido: {#archived--no-longer-maintained} diff --git a/src/content/translations/pt-br/developers/docs/programming-languages/rust/index.md b/src/content/translations/pt-br/developers/docs/programming-languages/rust/index.md index 2ce3f73ed65..2e28e0d24eb 100644 --- a/src/content/translations/pt-br/developers/docs/programming-languages/rust/index.md +++ b/src/content/translations/pt-br/developers/docs/programming-languages/rust/index.md @@ -30,9 +30,6 @@ Precisa de uma introdução geral? Confira [ethereum.org/learn](/learn/) ou [eth ## Artigos para intermediários {#intermediate-articles} -- [Documentação Rust-Web3](https://tomusdrw.github.io/rust-web3/web3/index.html) -- [Exemplos de trabalho Rust-Web3](https://github.com/tomusdrw/rust-web3/blob/master/examples) - ## Padrões de utilização avançada {#advanced-use-patterns} - [pwasm_ethereum: biblioteca externa para interagir com uma rede análoga a Ethereum](https://github.com/openethereum/pwasm-ethereum) @@ -40,21 +37,20 @@ Precisa de uma introdução geral? Confira [ethereum.org/learn](/learn/) ou [eth - [Construa um aplicativo descentralizado de tarefas utilizando Vue.js & Rust](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb) - [Uma Introdução a Contratos Secretos](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) -- [Construa uma blockchain em Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) +- [Construir uma blockchain no Rust](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) ## Projetos e ferramentas em Rust {#rust-projects-and-tools} -- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _Coleção de externos para interagir com uma rede análoga à Ethereum._ -- [Lighthouse](https://github.com/sigp/lighthouse) - _Cliente da camada de consenso de Ethereum rápida_ -- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _Reconcepção proposta da camada de execução de contrato inteligente Ethereum usando um subconjunto determinístico de WebAssembly_ +- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) — _Coleção de externos para interagir com uma rede análoga ao Ethereum._ +- [Lighthouse](https://github.com/sigp/lighthouse) — _Cliente rápido da camada de consenso do Ethereum_ +- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) — _Proposta de reformulação da camada de execução de contrato inteligente do Ethereum usando um subconjunto determinístico do WebAssembly_ - [oasis_std](https://docs.rs/oasis-std/0.2.7/oasis_std/) - _referência da API OASIS_ -- [Solaris](https://github.com/paritytech/sol-rs) - _Teste unitário de contratos inteligentes em Solidity que aproveita a Parity Client EVM nativo._ -- [SputnikVM](https://github.com/rust-blockchain/evm) - _Implementação de Máquina Virtual de Ethereum em Rust_ -- [rust-web3](https://github.com/tomusdrw/rust-web3) - _implementação em Rust da biblioteca Web3.js_ -- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Contrato inteligente Wavelet em Rust_ -- [Foundry](https://github.com/gakonst/foundry)- _Conjunto de ferramentas para o desenvolvimento do aplicativo Ethereum_ -- [Ethers_rs](https://github.com/gakonst/ethers-rs)- _Implementação da biblioteca e carteira Ethereum_ -- [SewUp](https://github.com/second-state/SewUp) - _Uma biblioteca para ajudá-lo a construir seu contrato Ethereum webassembly com Rust e, assim, desenvolver em um backend comum_ +- [Solaris](https://github.com/paritytech/sol-rs) — _Agente de teste unitário dos contratos inteligentes no Solidity usando o EVM nativo do cliente Parity._ +- [SputnikVM](https://github.com/rust-blockchain/evm) — _Implementação da Máquina Virtual do Ethereum no Rust_ +- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _smart contract Wavelet em Rust_ +- [Foundry](https://github.com/gakonst/foundry) — _Conjunto de ferramentas para o desenvolvimento de aplicativos Ethereum_ +- [Ethers_rs](https://github.com/gakonst/ethers-rs) — _Implementação da biblioteca e da carteira Ethereum_ +- [SewUp](https://github.com/second-state/SewUp) — _Uma biblioteca para ajudar você a construir seu contrato Webassembly do Ethereum com o Rust e desenvolvê-lo em um back-end comum_ - [Reth](https://github.com/paradigmxyz/reth) Reth (abreviação de Rust Ethereum, pronúncia) é uma nova implementação de nó completo do Ethereum Procurando por mais recursos? Leia [ethereum.org/developers.](/developers/) diff --git a/src/content/translations/pt-br/developers/docs/standards/tokens/erc-20/index.md b/src/content/translations/pt-br/developers/docs/standards/tokens/erc-20/index.md index 4500562d374..f0b84354eb3 100644 --- a/src/content/translations/pt-br/developers/docs/standards/tokens/erc-20/index.md +++ b/src/content/translations/pt-br/developers/docs/standards/tokens/erc-20/index.md @@ -146,3 +146,4 @@ print("Addr Balance:", addr_balance) - [EIP-20: Padrão de token ERC-20](https://eips.ethereum.org/EIPS/eip-20) - [OpenZeppelin: Tokens](https://docs.openzeppelin.com/contracts/3.x/tokens#ERC20) - [OpenZeppelin: Implementação ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol) +- [Alchemy — Guia para os Tokens ERC20 do Solidity](https://www.alchemy.com/overviews/erc20-solidity) diff --git a/src/content/translations/pt-br/developers/docs/standards/tokens/erc-4626/index.md b/src/content/translations/pt-br/developers/docs/standards/tokens/erc-4626/index.md index 9e08d622d85..7f027def39e 100644 --- a/src/content/translations/pt-br/developers/docs/standards/tokens/erc-4626/index.md +++ b/src/content/translations/pt-br/developers/docs/standards/tokens/erc-4626/index.md @@ -134,7 +134,7 @@ Esta função queima `shares` do `owner` e envia exatamente tokens `assets` do c function maxRedeem(address owner) public view returns (uint256) ``` -Esta função retorna a quantidade máxima de shares que podem ser resgatados do saldo do `owner` com uma chamada [`redeem`](#redeem). +Essa função retorna a quantidade máxima de ações que podem ser resgatadas do saldo do `owner` com uma chamada de [`redeem`](#redeem). #### previewRedeem {#previewredeem} @@ -142,7 +142,7 @@ Esta função retorna a quantidade máxima de shares que podem ser resgatados do function previewRedeem(uint256 shares) public view returns (uint256) ``` -Esta função permite aos usuários simular os efeitos de seu resgate no bloco atual. +Essa função permite aos usuários simular os efeitos de seu resgate no bloco atual. #### redeem {#redeem} @@ -150,7 +150,7 @@ Esta função permite aos usuários simular os efeitos de seu resgate no bloco a function redeem(uint256 shares, address receiver, address owner) public returns (uint256 assets) ``` -Esta função resgata um número específico de `shares` do `owner` e envia `assets` do token subjacente do cofre para o `receiver`. +Essa função resgata um número específico de `shares` do `owner` e envia `assets` do token subjacente do cofre para o `receiver`. #### totalSupply {#totalsupply} diff --git a/src/content/translations/pt-br/developers/docs/transactions/gas-tx.png b/src/content/translations/pt-br/developers/docs/transactions/gas-tx.png new file mode 100644 index 00000000000..0ffd5869b72 Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/transactions/gas-tx.png differ diff --git a/src/content/translations/pt-br/developers/docs/transactions/tx.png b/src/content/translations/pt-br/developers/docs/transactions/tx.png new file mode 100644 index 00000000000..36fb3c9e695 Binary files /dev/null and b/src/content/translations/pt-br/developers/docs/transactions/tx.png differ diff --git a/src/content/translations/pt-br/energy-consumption/energy_consumption_pre_post_merge.png b/src/content/translations/pt-br/energy-consumption/energy_consumption_pre_post_merge.png new file mode 100644 index 00000000000..1a6037280ca Binary files /dev/null and b/src/content/translations/pt-br/energy-consumption/energy_consumption_pre_post_merge.png differ diff --git a/src/content/translations/pt-br/energy-consumption/index.md b/src/content/translations/pt-br/energy-consumption/index.md index cbc34174c7a..94c082db538 100644 --- a/src/content/translations/pt-br/energy-consumption/index.md +++ b/src/content/translations/pt-br/energy-consumption/index.md @@ -6,69 +6,72 @@ lang: pt-br # Gasto de energia do Ethereum {#proof-of-stake-energy} -Ethereum é uma cadeia de blocos verde. Ele usa um mecanismo de consenso chamado [prova de participação](/developers/docs/consensus-mechanisms/pos/), que usa ETH ao invés de [energia para proteger a rede](/developers/docs/consensus-mechanisms/pow/). O mecanismo de prova de participação do Ethereum usa apenas [~0,0026 TWh/ano](https://carbon-ratings.com/eth-report-2022) em toda a rede global. +Ethereum é uma cadeia de blocos verde. A [prova de participação](/developers/docs/consensus-mechanisms/pos) do Ethereum usa o ETH como mecanismo de consenso ao invés de [energia para proteger a rede](/developers/docs/consensus-mechanisms/pow). O consumo de energia do Ethereum é de aproximadamente [~0,0026 TWh/ano](https://carbon-ratings.com/eth-report-2022) em toda a rede global. -O [CCRI (Crypto Carbon Ratings Institute)](https://carbon-ratings.com) gerou estimativas do consumo de eletricidade e da pegada de carbono da rede Ethereum ([veja o relatório](https://carbon-ratings.com/eth-report-2022)). Eles mediram o consumo de eletricidade de diferentes nós com várias configurações de hardware e software cliente. Isso gerou uma estimativa de **2,601 MWh** (0,0026 TWh) para o consumo anual de eletricidade da rede (setembro de 2022), correspondente a **870 toneladas de CO2, ** com a aplicação de fatores de intensidade de carbono específicos de cada região. +O consumo de energia estimado para o Ethereum vem de um estudo do [CCRI (Crypto Carbon Ratings Institute)](https://carbon-ratings.com). Eles geraram estimativas de baixo para cima do consumo de eletricidade e dos rastros de carbono da rede Ethereum ([veja o relatório](https://carbon-ratings.com/eth-report-2022)). Eles mediram o consumo de eletricidade de diferentes nós com várias configurações de hardware e software cliente. A estimativa de **2,601 MWh** (0,0026 TWh) para o consumo anual de eletricidade da rede é correspondente a emissões anuais de carbono de **870 toneladas de CO2e**, aplicando fatores de intensidade de carbono específicas de uma região. Esse valor muda à medida que os nós entram e saem da rede — você pode acompanhar isso utilizando uma média estimada de 7 dias pelo [Índice de Sustentabilidade da rede Cambridge Blockchain](https://ccaf.io/cbnsi/ethereum) (observe que eles usam um método ligeiramente diferente para suas estimativas — detalhes disponíveis no site). + +Para contextualizar o consumo de energia do Ethereum, nós podemos comparar as estimativas anualizadas de outros setores. Isso nos ajuda a entender melhor se a estimativa do Ethereum é alta ou baixa. -O gráfico acima mostra o consumo anual estimado de energia em TWh/ano para vários setores (recuperado em junho de 2022). Observe que as estimativas apresentadas no gráfico são de fontes disponíveis publicamente e seus links se encontram na tabela abaixo. CEBCI refere-se ao índice Cambridge Bitcoin Electricity Consumption. Os valores são ilustrativos e não representam estimativa, compromisso ou previsão oficial. +O gráfico acima apresenta o consumo anual de energia estimada em TWh/ano para o Ethereum, em comparação com outros diversos setores. As estimativas fornecidas são derivadas de informações disponíveis ao público, acessadas em maio de 2023, com links para as fontes disponíveis no quadro abaixo: + +| | Consumo de energia anualizado (TWh) | Comparação com a PoS Ethereum | Fonte | +| :---------------------------- | :---------------------------------: | :---------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Centros de dados globais | 200 | 77.000x | [fonte](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches) | +| Mineração de ouro | 131 | 50.000x | [fonte](https://ccaf.io/cbnsi/cbeci/comparisons) | +| Bitcoin | 131 | 50.000x | [fonte](https://ccaf.io/cbnsi/cbeci/comparisons) | +| PoW Ethereum | 78 | 30.000x | [fonte](https://digiconomist.net/ethereum-energy-consumption) | +| YouTube (somente diretamente) | 12 | 4.600x | [fonte](https://www.gstatic.com/gumdrop/sustainability/google-2020-environmental-report.pdf) | +| Gaming nos EUA | 34 | 13.000x | [fonte](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential) | +| Netflix | 0,451 | 173x | [fonte](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) | +| PayPal | 0,26 | 100x | [fonte](https://app.impaakt.com/analyses/paypal-consumed-264100-mwh-of-energy-in-2020-24-from-non-renewable-sources-27261) | +| AirBnB | 0,02 | 8x | [fonte]() | +| PoS Ethereum | 0,0026 | 1x | [fonte](https://carbon-ratings.com/eth-report-2022) | -Para contextualizar o consumo de energia do Ethereum, podemos comparar estimativas anualizadas para outras indústrias, o que nos permite entender melhor se 0,0026 TWh é muito ou pouco. Os dados estão resumidos no gráfico de barras acima, e mais detalhes são fornecidos na tabela abaixo: +É complicado adquirir estimativas exatas do consumo de energia, especialmente quando o que está sendo medido tem uma cadeia complexa de suprimentos ou detalhes de implantação que influenciam sua eficiência. Considere a Netflix ou o YouTube como exemplos. As estimativas do seu consumo de energia podem variar dependendo se incluem apenas a energia usada para preservar seus sistemas e entregar satisfação aos usuários (_despesas diretas_) ou se eles incluem as despesas necessárias para gerar satisfação, administrar escritórios corporativos, anunciar, etc. (_despesas indiretas_). O uso indireto também pode incluir a energia necessária para consumir conteúdo em dispositivos do usuário final, como TVs, computadores e celulares, que, por outro lado, depende de quais dispositivos são usados. -| | Consumo de energia anualizado (TWh) | Comparação com a PoS Ethereum | Fonte | -| :----------------------- | :---------------------------------: | :---------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------ | -| Mineração de ouro | 240 | 92.000x | [fonte](https://www.kitco.com/news/2021-05-17/Gold-s-energy-consumption-doubles-that-of-bitcoin-Galaxy-Digital.html) | -| Mineração de Ouro | 130 | 50.000x | [fonte](https://ccaf.io/cbeci/index/comparisons) | -| Bitcoin | 130 | 50.000x | [fonte](https://digiconomist.net/bitcoin-energy-consumption) | -| Bitcoin | 100 | 38.000x | [fonte](https://ccaf.io/cbeci/index/comparisons) | -| YouTube | 244 | 94.000 x | [fonte](https://thefactsource.com/how-much-electricity-does-youtube-use/) | -| Centros de dados globais | 200 | 78.000x | [fonte](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches) | -| Netflix | 0,45 | 175x | [fonte](https://s22.q4cdn.com/959853165/files/doc_downloads/2020/02/0220_Netflix_EnvironmentalSocialGovernanceReport_FINAL.pdf) | -| Netflix | 94 | 36.000x | [fonte](https://theshiftproject.org/en/article/unsustainable-use-online-video/) | -| PayPal | 0,26 | 100x | [fonte](https://app.impaakt.com/analyses/paypal-consumed-264100-mwh-of-energy-in-2020-24-from-non-renewable-sources-27261) | -| Jogos nos EUA | 34 | 13.000x | [fonte](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential) | -| PoW Ethereum | 78 | 30.000x | [fonte](https://digiconomist.net/ethereum-energy-consumption) | -| PoS Ethereum | 0,0026 | 1x | [fonte](https://carbon-ratings.com/eth-report-2022) | +Há uma discussão sobre isso no [Carbon Brief](https://www.carbonbrief.org/factcheck-what-is-the-carbon-footprint-of-streaming-video-on-netflix). No quadro acima, o valor indicado para a Netflix inclui o valor autodeclarado de utilização _direta_ e _indireta_. O Youtube disponibiliza apenas uma aproximação da própria despesa _direta_ de energia, que chega a [12 TWh/ano](https://www.gstatic.com/gumdrop/sustainability/google-2020-environmental-report.pdf). -As estimativas do gasto de energia do YouTube também foram discriminadas por canal e vídeos individuais. [Essas estimativas](https://thefactsource.com/how-much-electricity-does-youtube-use/) mostram que o YouTube usou 175 vezes mais energia assistindo Gangnam Style em 2019 do que a Ethereum usa por ano. +A tabela e o gráfico acima também incluem comparações com o Bitcoin e a prova de trabalho do Ethereum. É importante notar que o consumo de energia das redes de prova de trabalho não é estático — ele muda a cada dia. O valor usado para a prova de trabalho do Ethereum foi um pouco antes do [The Merge](/roadmap/merge/) para prova de participação, como previsto pelo [Digiconomist](https://digiconomist.net/ethereum-energy-consumption). Outras fontes, como o [Índice de Sustentabilidade da rede Cambridge Blockchain](https://ccaf.io/cbnsi/ethereum/1) estimam que o consumo de energia tenha sido muito menor (mais próximo de 20 TWh/ano). As estimativas para o consumo de energia do Bitcoin também mudam muito entre as fontes e é um tema que atrai muitos [debates](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/) sobre não apenas a quantidade de carga consumida, mas também as fontes dessa energia e a ética relacionada com ela. O consumo de energia não corresponde necessariamente à pegada ambiental, porque diferentes projetos podem utilizar diferentes fontes de energia como, por exemplo, uma proporção menor ou maior de energias renováveis. Por exemplo, o [Índice de Consumo de Eletricidade Bitcoin de Cambridge](https://ccaf.io/cbnsi/cbeci/comparisons) indicam que a demanda da rede Bitcoin poderia, teoricamente, ser alimentada por queima de gás ou de eletricidade que, de certa forma, seria perdida na transmissão e distribuição. O caminho do Ethereum para a sustentabilidade foi substituir a parte que consume muita energia da rede por uma alternativa ecológica. -É complicado obter estimativas precisas de consumo de energia, especialmente quando o que está sendo medido tem uma cadeia de suprimentos complexa ou detalhes de implantação que influenciam sua eficiência. Por exemplo, incluímos uma estimativa máxima e mínima para a mineração de ouro que diverge em cerca de 90 TWh. As estimativas de consumo de energia da Netflix variam drasticamente, dependendo da fonte. Suas próprias estimativas relatadas são cerca de 20 vezes menores do que uma estimativa independente. Veja algumas discussões sobre as razões para esse fenômeno em [Carbon Brief](https://www.carbonbrief.org/factcheck-what-is-the-carbon-footprint-of-streaming-video-on-netflix). Da mesma forma, estima-se que o YouTube gaste cerca de [244 TWh/ano](https://thefactsource.com/how-much-electricity-does-youtube-use/), embora o consumo de energia dependa muito do tipo de dispositivo no qual os vídeos são transmitidos e a eficiência energética da infraestrutura subjacente, como data centers. No entanto, é difícil estimar valores adequados para esses parâmetros, gerando uma incerteza substancial. +Você pode consultar as estimativas do consumo de energia e emissão de carbono no [site Índice de Sustentabilidade da rede Cambridge Blockchain](https://ccaf.io/cbnsi/ethereum). -O gráfico acima também inclui comparações com Bitcoin e Ethereum (enquanto este ainda usava o mecanismo de prova de trabalho). As estimativas para o consumo de energia do Bitcoin variam amplamente entre as fontes e é um tópico que atrai muitos [debates](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/), não apenas sobre a quantidade de energia consumida, mas também sobre as fontes dessa energia e a ética associada a elas. +## Estimativas por transação {#per-transaction-estimates} -Muitos artigos estimam o gasto de energia "por transação" para blockchains. Isso pode ser enganoso, porque a energia necessária para propor e validar um bloco é independente do número de transações dentro dele. Uma unidade de gasto de energia por transação implica que menos transações levariam a um gasto de energia menor e vice-versa, o que não é o caso. Além disso, as estimativas por transação são muito sensíveis a como uma taxa de transferência de transação da blockchain é definida, e o ajuste dessa definição pode ser burlado para fazer o valor parecer maior ou menor. +Muitos artigos estimam o gasto de energia “por transação” para blockchains. Isso pode ser enganoso, pois a energia necessária para propor e validar um bloco é independente do número de transações dentro dele. Uma unidade de gasto de energia por transação implica que menos transações levariam a um gasto de energia menor e vice-versa, o que não é o caso. Além disso, as estimativas por transação são muito sensíveis a como uma taxa de transferência de transação da blockchain é definida, e o ajuste dessa definição pode ser burlado para fazer o valor parecer maior ou menor. -Por exemplo, na Ethereum, a taxa de transferência de transação não é apenas a da camada base – ela também é a soma da taxa de transferência de transação de todos os seus roll-ups de "[camada 2](/layer-2/) ". Geralmente, as camadas 2 não são incluídas nos cálculos, mas contabilizar a energia adicional consumida pelos sequenciadores (pequenos) e o número de transações que eles processam (grandes) provavelmente reduziria drasticamente as estimativas por transação. Esta é uma razão pela qual as comparações do consumo de energia por transação entre plataformas podem ser enganosas. +Por exemplo, no Ethereum, a taxa de transferência de transação não é apenas a da camada base — ela também é a soma da taxa de transferência de transação de todos os seus roll-ups de “[camada 2](/layer-2/)”. Geralmente, as camadas 2 não são incluídas nos cálculos, mas contabilizar a energia adicional consumida pelos sequenciadores (pequenos) e o número de transações que eles processam (grandes) provavelmente reduziria drasticamente as estimativas por transação. Essa é uma razão pela qual as comparações do consumo de energia por transação entre plataformas podem ser enganosas. ## Deficit de carbono do Ethereum {#carbon-debt} -O gasto de energia do Ethereum é muito baixo, mas nem sempre tem sido o caso. O Ethereum originalmente usava prova de trabalho, que tinha um custo ambiental muito maior do que o mecanismo atual de prova de participação. +O gasto de energia do Ethereum é muito baixo, mas nem sempre tem sido o caso. Originalmente, o Ethereum usava prova de trabalho, que tinha um custo ambiental muito maior do que o mecanismo atual de prova de participação. -Desde o início, o Ethereum planejou implementar um mecanismo de consenso baseado em prova de participação, mas fazer isso sem sacrificar a segurança e a descentralização levou anos de pesquisa e desenvolvimento focados. Portanto, um mecanismo de prova de trabalho foi usado para iniciar a rede. A prova de trabalho exige que mineradores usem seu hardware de computação para calcular um valor, gastando energia no processo. O consumo total de energia do Ethereum atingiu seu pico durante o ápice do mercado em alta de criptomoedas em fevereiro de 2022, a pouco menos de 94 TWh/ano. Pouco antes da mudança para prova de participação, o consumo de energia estava mais próximo de [78 TWh/ano](https://digiconomist.net/ethereum-energy-consumption), comparável ao do Uzbequistão, com uma emissão de carbono equivalente à do Azerbaijão (33 MT/ano). +Desde o início, o Ethereum planejou implementar um mecanismo de consenso baseado em prova de participação, mas fazer isso sem sacrificar a segurança e a descentralização levou anos de pesquisa e desenvolvimento focados. Portanto, um mecanismo de prova de trabalho foi usado para iniciar a rede. A prova de trabalho exige que mineradores usem seu hardware de computação para calcular um valor, gastando energia no processo. -![Comparação do consumo de energia do Ethereum antes e depois da Fusão. Exibe, à esquerda, a torre Eiffel com 330 metros de altura e, à direita, uma figura de brinquedo de plástico com 4 cm de altura visto de dentro de uma lupa.](energy_consumption_pre_post_merge.png) +![Comparação do consumo de energia do Ethereum antes e depois da fusão (The Merge), usando a Torre Eiffel (330 metros de altura) à esquerda, para simbolizar o elevado consumo de energia antes do The Merge, e uma pequena figura de Lego de 4 cm de altura à direta, para representar a redução drástica do consumo de energia após o The Merge.](energy_consumption_pre_post_merge.png) -O CCRI examinou o impacto da transição do Ethereum de prova de trabalho para prova de participação. O consumo anualizado de eletricidade foi reduzido em mais de **99,988 %**. Da mesma forma, a emissão de carbono do Ethereum foi reduzido em aproximadamente **99,992%** (de 11.016.000 para 870 toneladas de CO2e). Representado metaforicamente, isso corresponde a uma redução nas emissões da altura da Torre Eiffel para uma pequena figura de brinquedo de plástico, conforme mostrado na figura acima. Portanto, o custo ambiental de proteção da rede é drasticamente reduzido. Simultaneamente, estima-se que a segurança da rede tenha aumentado. +CCRI estima que o The Merge reduziu o consumo anual de eletricidade do Ethereum em mais de **99,988%**. Da mesma forma, a emissão de carbono do Ethereum foi reduzido em aproximadamente **99,992%** (de 11.016.000 para 870 toneladas de CO2e). Para colocar isso em perspectiva, a redução das emissões é como ir da altura da Torre Eiffel para um brinquedinho de plástico, como ilustrado na figura acima. Consequentemente, o custo ambiental da segurança da rede é drasticamente reduzido. Ao mesmo tempo, acredita-se que a segurança da rede tenha melhorado. -## Uma camada de aplicação verde {#green-applications} +## Uma camada de aplicação ecológica {#green-applications} -Embora o consumo de energia do Ethereum seja muito baixo, há também uma comunidade sobre **finanças regenerativas (ReFi)** substancial, crescente e altamente ativa construída no Ethereum. Os aplicativos ReFi usam componentes DeFi para construir aplicações financeiras com externalidades positivas benéficas para o ambiente. O ReFi faz parte de um movimento ["solarpunk"](https://en.wikipedia.org/wiki/Solarpunk) mais amplo que está intimamente alinhado com o Ethereum e visa unir o avanço tecnológico e a gestão ambiental. A natureza descentralizada, sem permissão e combinável do Ethereum faz dele a camada base ideal para as comunidades ReFi e solarpunk. +Embora o consumo de energia do Ethereum seja muito baixo, há também uma comunidade sobre **finanças regenerativas (ReFi)** substancial, crescente e altamente ativa construída no Ethereum. Os aplicativos ReFi usam componentes DeFi para construir aplicativos financeiros com externalidades positivas benéficas para o ambiente. O ReFi faz parte de um movimento [“solarpunk”](https://en.wikipedia.org/wiki/Solarpunk) mais amplo, que está intimamente alinhado com o Ethereum e visa unir o avanço tecnológico e a gestão ambiental. A natureza descentralizada, sem permissão e combinável do Ethereum faz dele a camada base ideal para as comunidades ReFi e solarpunk. As plataformas nativas de financiamento de bens públicos da Web3, como [Gitcoin](https://gitcoin.co), executam rodadas climáticas para estimular uma construção com consciência ambiental na camada de aplicações do Ethereum. Por meio do desenvolvimento dessas iniciativas (e outras, por exemplo, [DeSci](/desci/)), o Ethereum está se tornando uma tecnologia social e ambientalmente positiva. - Se você acha que esta página pode ser mais precisa, comunique o problema ou PR. As estatísticas nesta página são estimativas baseadas em dados disponíveis publicamente – elas não representam uma declaração oficial ou promessa da equipe ethereum.org ou da Ethereum Foundation. + Se você acha que esta página pode ser mais precisa, comunique o problema ou PR. As estatísticas nesta página são estimativas baseadas em dados disponíveis publicamente – elas não representam uma declaração oficial ou promessa da equipe ethereum.org ou da Ethereum Foundation. ## Leitura adicional {#further-reading} +- [Índice de Sustentabilidade da rede Cambridge Blockchain](https://ccaf.io/cbnsi/ethereum) - [Relatório da Casa Branca sobre blockchains de prova de trabalho](https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf) -- [Consumo de energia do Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8) - [Emissões do Ethereum: uma estimativa minuciosa](https://kylemcdonald.github.io/ethereum-emissions/) _ Kyle McDonald_ - [Índice de consumo de energia do Ethereum](https://digiconomist.net/ethereum-energy-consumption/) – _Digiconomist_ - [ETHMerge.com](https://ethmerge.com/) — _[@InsideTheSim](https://twitter.com/InsideTheSim)_ - [A Fusão — As Implicações no Consumo de Eletricidade e Emissão de Carbono da Rede Ethereum](https://carbon-ratings.com/eth-report-2022) - _CCRI_ +- [Consumo de energia do Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8) ## Tópicos relacionados {#related-topics} diff --git a/src/content/translations/pt-br/staking/solo/index.md b/src/content/translations/pt-br/staking/solo/index.md index b135716fef8..5e4fbbd8c6e 100644 --- a/src/content/translations/pt-br/staking/solo/index.md +++ b/src/content/translations/pt-br/staking/solo/index.md @@ -40,31 +40,36 @@ A participação individual vem com mais responsabilidades, mas fornece o máxim Por mais que desejemos que o staking individual fosse acessível e sem riscos para todos, isso não é a realidade. Existem algumas considerações práticas e sérias a serem lembradas antes de optar por fazer staking individual de seu ETH. - - Ao operar seu próprio nó, você deve gastar algum tempo aprendendo a usar o software que escolheu. Isso envolve ler a documentação relevante e estar em sintonia com os canais de comunicação dessas equipes de desenvolvimento. + +Ao operar seu próprio nó, você deve gastar algum tempo aprendendo a usar o software que escolheu. Isso envolve ler a documentação relevante e estar em sintonia com os canais de comunicação dessas equipes de desenvolvimento. Quanto mais você entender sobre o software que está executando e como funciona a prova de participação (proof of sake), menos arriscado será como um staker e mais fácil será corrigir quaisquer problemas que possam surgir ao longo do caminho como operador de nó. + A configuração do nó requer um nível de conforto razoável ao trabalhar com computadores, embora novas ferramentas estejam tornando isso mais fácil com o tempo. A compreensão da interface de linha de comando é útil, mas não é mais estritamente necessária. Também requer uma configuração de hardware muito básica e alguma compreensão das especificações mínimas recomendadas. + Assim como as chaves privadas protegem seu endereço Ethereum, você precisará gerar chaves especificamente para seu validador. Você deve saber como manter todas as frases de recuperação ou chaves privadas seguras e protegidas. -[Segurança do Ethereum e prevenção contra golpes](/security/) +Segurança e prevenção contra fraudes do Ethereum + O hardware falha ocasionalmente, as conexões de rede falham e o software cliente ocasionalmente precisa ser atualizado. A manutenção do nó é inevitável e ocasionalmente exigirá sua atenção. Você deve estar ciente de quaisquer informações de atualizações de rede ou outras atualizações críticas de clientes. + Suas recompensas são proporcionais ao tempo que seu validador está on-line e atestando corretamente. O tempo de inatividade incorre em penalidades proporcionais a quantos outros validadores estão off-line ao mesmo tempo, mas não resulta em cortes. A largura de banda também é importante, pois as recompensas são reduzidas para declarações que não são recebidos a tempo. Os requisitos variam, mas é recomendado um mínimo de 10 Mb/s de upload e download. + Diferente das penalidades de inatividade por estar off-line, o corte é uma penalidade muito mais séria reservada para infrações maliciosas. Ao executar um cliente minoritário com suas chaves carregadas em apenas uma máquina por vez, o risco de ser cortado é minimizado. Dito isto, todos os stakers devem estar cientes dos riscos de serem cortados. -[Saiba mais sobre remoção e ciclo de vida do validador](https://medium.com/prysmatic-labs/eth2-slashing-prevention-tips-f6faa5025f50/) +Mais sobre remoção e o ciclo de vida do validador @@ -124,7 +129,7 @@ Estas são algumas das perguntas mais comuns sobre staking que vale a pena conhe -Um _validador_ é uma entidade virtual que vive no Ethereum e participa do consenso do protocolo Ethereum. Os validadores são representados por um saldo, chave pública e outras propriedades. Um _cliente validador_ é o software que atua em nome do validador mantendo e usando sua chave privada. Um único cliente validador pode conter muitos pares de chaves, controlando muitos validadores. +Um validador é uma entidade virtual que vive no Ethereum e participa no consenso do protocolo Ethereum. Os validadores são representados por um saldo, chave pública e outras propriedades. Um cliente validador é o software que atua em nome do validador mantendo e usando sua chave privada. Um único cliente validador pode conter muitos pares de chaves, controlando muitos validadores. @@ -153,8 +158,10 @@ A execução de um cliente supermajoritário (qualquer cliente usado por mais de Falhas equivalentes em um cliente minoritário jamais seriam finalizadas, portanto, nunca resultariam em um voto cercado, e simplesmente resultariam em penalidades de inatividade, não em cortes. -

Saiba mais sobre a importância de administrar um cliente minoritário.

-

Saiba mais sobre a prevenção de cortes

+ diff --git a/src/content/translations/pt-br/staking/withdrawals/index.md b/src/content/translations/pt-br/staking/withdrawals/index.md index b14e9ce8fba..870fbae325b 100644 --- a/src/content/translations/pt-br/staking/withdrawals/index.md +++ b/src/content/translations/pt-br/staking/withdrawals/index.md @@ -151,9 +151,11 @@ title="E se eu participar de derivativos líquidos de staking ou staking combina eventCategory="FAQ" eventAction="What if I participate in liquid staking derivatives or pooled staking" eventName="read more"> + Se você faz parte de um pool de stake ou possui derivados de stake líquidos, você deve solicitar ao seu provedor mais detalhes sobre como os saques de stake são tratados, pois cada serviço opera de maneira diferente. -Em geral, os usuários podem recuperar seu ETH subjacente em stake ou alterar o provedor de stake que utilizam quando quiserem. Se um pool em particular estiver ficando muito grande, os fundos podem ser sacados, resgatados e recolocados em stake com um [provedor menor](https://rated.network/). Ou então, se você acumulou ETH suficiente, poderá [colocar em stake de casa](/staking/solo/). +Em geral, os usuários podem recuperar seu ETH subjacente em stake ou alterar o provedor de stake que utilizam quando quiserem. Se um pool em particular estiver ficando muito grande, os fundos podem ser encerrados, resgatados e reinvestidos com um provedor menor. Ou então, se você acumulou ETH suficiente, pode fazer stake em casa. + + Não, se o seu validador ainda estiver ativo na rede, um saque total não acontecerá automaticamente. Isso exige iniciar manualmente uma saída voluntária. -Uma vez que um validador tenha concluído o processo de saída e, supondo que a conta tenha credenciais de saque, o saldo restante será então sacado durante a próxima [varredura do validador](#validator-sweeping). +Após um validador ter concluído o processo de saída, e presumindo que a conta tenha credenciais de saque, o saldo restante será então sacado durante a próxima varredura do validador. + + Recomenda-se que os operadores do validador visitem a página Plataforma de Saque de Stake, na qual você encontrará mais detalhes sobre como preparar seu validador para saques. preparado, tempo de eventos e mais detalhes sobre como funcionam os saques. -Para testar sua configuração em uma rede de testes primeiro, visite a [Plataforma de Stake de Testes da Goerli](https://goerli.launchpad.ethereum.org) para começar. +Para testar a sua configuração numa rede de testes, primeiro visite o Goerli Testnet Staking Launchpad para começar. +
如果你是剛開始使用以太坊，請嘗試我們推薦的去中心化金融應用程式。
@@ -143,7 +143,7 @@ Dai、USDC 等穩定幣的價值和美元的差距通常維持在幾美分之內 #### 納稅效益 {#tax-efficiencies} -借款可以讓你獲得需要的資金，而無需出售以太幣（此行為會被課稅）。 相對地，你可以使用以太幣作為抵押品來借入穩定幣。 如果一來，你便可以在保有以太幣的情況下，獲得所需的現金流。 穩定幣是需要現金時的最佳選擇，因為穩定幣不像以太幣一樣易於波動。 [深入了解穩定幣](#stablecoins) +借款可以讓你獲得需要的資金，而無需出售以太幣（此行為會被課稅）。 相對地，你可以使用以太幣作為抵押品來借入穩定幣。 如此一來，你便可以在保有以太幣的情況下，獲得所需的現金流。 穩定幣是需要現金時的最佳選擇，因為穩定幣的價值不像以太幣一樣易於波動。 [深入了解穩定幣](#stablecoins) #### 閃電貸 {#flash-loans} @@ -162,7 +162,7 @@ Dai、USDC 等穩定幣的價值和美元的差距通常維持在幾美分之內 - 你以 $1.00 的價格，從 A 交易所借入 X 數量的 $asset - 你在 B 交易所以 $1.10 的價格售出 X 數量的 $asset - 接著，你到 A 交易所償還貸款 -- 你賺得了扣除手續費後的利潤 +- 你賺得了扣除交易手續費後的利潤 如果 B 交易所的供給量急速下降，使用者無法購足量額來償還原始貸款，那麼這筆交易就會失敗。 @@ -180,7 +180,7 @@ Dai、USDC 等穩定幣的價值和美元的差距通常維持在幾美分之內 - 你借出 100 Dai（一種[穩定幣](/stablecoins/)）給某個類似 Aave 的產品。 - 你會收到 100 Aave Dai (aDai)，此代幣代表著你借出的 Dai。 -- 你的 aDai 會按利率增加，你可以看到錢包裡的餘額在成長。 視年利率而定，幾天或甚至幾小時後，你的錢包餘額可能會變成 100.1234！ +- 你的 aDai 會按利率增加，你可以看到錢包裡的餘額在增長。 視年利率而定，幾天或甚至幾小時後，你的錢包餘額可能會變成 100.1234！ - 你可以隨時提取和你的 aDai 餘額等額的一般 Dai。 @@ -207,7 +207,7 @@ Dai、USDC 等穩定幣的價值和美元的差距通常維持在幾美分之內 ### 兌換代幣 {#swaps} -以太坊有成千上萬種代幣。 去中心化交易所 (DEX) 可以讓你隨時交易不同代幣。 你永遠不必放棄對資產的控制權。 這就像造訪其他國家時到外幣收兌處換匯一樣。 但去中心化金融版本的收兌處永不關閉， 去中心化金融市場全天候開放，其技術可保證永遠有人受理交易。 +以太坊有成千上萬種代幣。 去中心化交易所 (DEX) 可以讓你隨時交易不同代幣。 你永遠不會放棄對資產的控制權。 這就像造訪其他國家時到外幣收兌處換匯一樣。 但去中心化金融版本的收兌處永不關閉， 去中心化金融市場全天候開放，其技術可保證永遠有人受理交易。 例如，如果你想使用無損樂透 PoolTogether（參閱前文），你需要 Dai 或 USDC 這類代幣。 這些去中心化交易所可讓你將以太幣兌換成這些代幣，完成交易後再兌換回來。 @@ -233,7 +233,7 @@ Dai、USDC 等穩定幣的價值和美元的差距通常維持在幾美分之內 以太坊上有一些資金管理產品可以根據你選擇的策略來擴展你的投資組合。 這是自動化作業，對所有人開放，而且不需要管理人員來分一杯羹。 -[DeFi Pulse 指數基金 (DPI)](https://defipulse.com/blog/defi-pulse-index/) 就是個很好的例子。 此基金會自動再平衡，以確保你的投資組合永遠包含[市值最高的去中心化金融代幣](https://www.coingecko.com/en/defi)。 你無需親力親為處理任何細節，而且可以隨時提取資金。 +[DeFi Pulse 指數基金 (DPI)](https://defipulse.com/blog/defi-pulse-index/) 就是個很好的例子。 此基金會自動再平衡，確保你的投資組合永遠包含[市值最高的去中心化金融代幣](https://www.coingecko.com/en/defi)。 你無需親力親為處理任何細節，而且可以隨時提取資金。 查看投資去中心化應用程式 @@ -322,7 +322,7 @@ Dai、USDC 等穩定幣的價值和美元的差距通常維持在幾美分之內 ## 建構去中心化金融 {#build-defi} -去中心化金融是一場開放原始碼運動。 去中心化金融協定和應用程式都是開放的，你可以自由檢視、分叉並進行各種創新。 因為採用分層堆疊結構（共享相同的基礎區塊鏈及資產），你可以結合和配對不同協定，開啟獨特的機會組合。 +去中心化金融是一場開放原始碼運動。 去中心化金融協議和應用程式都是開放的，你可以自由檢視、分叉並進行各種創新。 因為採用分層堆疊結構（共享相同的基礎區塊鏈及資產），你可以結合和配對不同協定，開啟獨特的機會組合。 關於建構去中心化應用程式 diff --git a/src/content/translations/zh-tw/desci/index.md b/src/content/translations/zh-tw/desci/index.md new file mode 100644 index 00000000000..6614c45748e --- /dev/null +++ b/src/content/translations/zh-tw/desci/index.md @@ -0,0 +1,138 @@ +--- +title: 去中心化科研 (DeSci) +description: 以太坊的去中心化科研概觀 +lang: zh-tw +template: use-cases +emoji: ":microscope:" +sidebarDepth: 2 +image: ../../../../assets/future_transparent.png +alt: "" +summaryPoint1: 當前科學系統的全球開放性替代方案。 +summaryPoint2: 使科學家得以進行募資、試驗研究、資料分享、發表見解等活動的技術。 +summaryPoint3: 以開放科學運動為原則。 +--- + +## 什麼是去中心化科研 (DeSci)？ {#what-is-desci} + +去中心化科研 (DeSci) 是一項利用 Web3 技術開發的公共基礎設施來推行的科學運動，以公平且公正合理的方式融資、研發、審核、認證、存檔以及推廣科學知識。 + +去中心化科研的目標是創建一個生態系統，鼓勵科學家公開分享研究計畫，在開放任何人輕易獲得甚至參與研究的同時，肯定該科學家的貢獻。 去中心化科研的理念是：所有人都有獲得科學知識的權利，因此科學研究過程應該透明化。 去中心化科研正在開創一種更去中心化且廣泛的科學研究模型，使其更能抵抗中心化管理機構的審查與控制。 去中心化科研的目標是，藉由融資、科研工具與交流渠道的去中心化，為跳脫框架的新點子開創出一個能夠欣欣向榮的環境。 + +去中心化科研獎勵可重複性，因而能激發更廣泛多元的融資方案（從[去中心化自治組織](/dao/)、[平方募資](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531)到群眾募資等），以及更容易獲得的資料與方法。 + +### Juan Benet - 去中心化科研運動 + + + +## 去中心化科研如何改善科學研究 {#desci-improves-science} + +這份有待補充的清單列出了科學領域中的關鍵問題，以及去中心化科研所能提供的協助方案 + +| **去中心化科研** | **傳統科研** | +| ---------------------------------------------------------------------- | ------------------------------------------------------------------------------ | +| 使用平方募資或去中心化自治組織等機制的公眾決定了資金的去向。 | 小型、封閉、中心化團體負責管控資金去向。 | +| 你能夠與世界各地的同儕展開活潑的合作。 | 合作計畫受資助方和所屬機構限制。 | +| 資金決策在線上進行且透明度高。 會探索全新的融資機制。 | 資金決策較為耗時且透明度不足。 融資機制有限。 | +| 利用 Web3 基礎單元更簡單且公開地分享實驗室服務。 | 分享實驗室資源的過程較為遲緩且透明度不足。 | +| 利用 Web3 基礎單元研發出可靠、透明且能與全球共享的全新發表模式。 | 只能藉由既有途徑發表研究，而這些途徑通常被認為缺乏效率、帶有偏見且有剝削傾向。 | +| 你可以藉由同儕審查工作獲得代幣與聲望。 | 同儕審查工作是無償的，只有商業出版商能獲益。 | +| 你產生的知識產權 (IP) 歸你所有且能根據透明條款加以分配。 | 你產生的知識產權歸屬於你所在的機構。 知識產權無法透明地獲得。 | +| 所有研究步驟將在鏈上公佈，無論研究成功與否，所有研究資料均在鏈上共享。 | 出版社不夠公正，導致研究者傾向只分享成功的實驗。 | + +## 以太坊與去中心化科研 {#ethereum-and-desci} + +去中心化科研系統需要健全的保全，將金錢與交易開銷減到最低，還要有能夠開發各種應用程式的豐富生態系統。 以太坊提供建立去中心化科研基礎所需的一切。 + +## 去中心化科研的使用案例 {#use-cases} + +去中心化科研正在構建科學研究工具組件，以便將 Web2 學術應用納入數位世界。 以下是 Web3 可爲科學領域提供的使用案例。 + +### 學術發表 {#publishing} + +現行科學研究發表模式備受質疑，因為這種模式由出版方主導，而出版方又仰賴科學家、審查者與編輯的無償勞動，卻又收取高昂的發表費用。 大眾讀者通常藉由稅收間接支付了該研究的費用，卻往往無法閱讀相同作品，除非再次付款給出版方。 發表單篇科學論文的費用通常高達五位數（美元），不但辜負科學知識作為[公共財產](https://www.econlib.org/library/Enc/PublicGoods.html)的使命，還為一小撮出版者帶來龐大利潤。 + +目前的免費公開平台通常是預印伺服器，[例如 ArXiv](https://arxiv.org/)。 然而，這些平台缺乏質量把關，無[防範女巫攻擊的機制](https://csrc.nist.gov/glossary/term/sybil_attack)，且通常不會追蹤文章等級指標，換言之，它們通常只供在投稿至傳統出版社之前流通作品。 SciHub 也提供免費瀏覽已發表的學術論文，但此途徑並不合法，且須待出版社收取報酬並將論文納入嚴格的版權法之後才得以在網站發布。 這開啟了一道關鍵缺口，也就是內建合法機制與激勵模型的開放式科學論文與資料。 Web3 能提供建立這種系統的工具。 + +### 可重複性與可複製性 {#reproducibility-and-replicability} + +可重複性和可複製性是科學研究的品質依據。 + +- 可重複的研究結果可由相同的團隊使用相同的方式多次達成。 +- 可複製的研究結果可由不同的團隊以相同的實驗方案達成。 + +全新的 Web3-內建工具可以確保科學發現以可重複性與可複製性為基礎。 我們可將優質的科學融入到學術界的技術體系中。 Web3 有能力驗證原始資料、計算引擎以及應用結果等分析要素。 共識系統的美妙之處在於，當這些要素由可靠的網路機制維護運作時，所有網絡參與者都可以負責再次運算並驗證每一項結果。 + +### 資金來源 {#funding} + +目前資助科學的標準模式是個人或科學家團體向資助機構提出書面申請。 小部分值得信賴的人為申請表評分，並面試這一小撮申請人，再給予資金。 這個模式不但容易造成瓶頸，導致申請和獲得資助之間有時需要等待好幾年，還被認為極易受到審查小組的偏見、自我利益和政治因素的影響。 + +研究顯示，同一個提案被提交到不同的小組時，結果卻大相徑庭，可見資助審查小組難以選出高品質提案。 隨著資金變得越來越稀缺，這些款項都集中在少數資深研究者與較為保守的研究計劃上。 這導致了一個各方為資金搶破頭的環境，還鞏固了不健康的激勵措施，並抑制創新。 + +Web3 廣泛試驗過去中心化自治組織和 Web3 開發的不同激勵模型，因而有可能改善這種糟糕的融資模型。 Web3 工具包括[追溯性公共財產資金](https://medium.com/ethereum-optimism/retroactive-public-goods-funding-33c9b7d00f0c)、[平方募資法](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531)、[去中心化自治組織治理](https://www.antler.co/blog/daos-and-web3-governance)和[代幣化激勵結構](https://cdixon.org/2017/05/27/crypto-tokens-a-breakthrough-in-open-network-design)，這些都可以徹底改變科研融資現況。 + +### 知識產權所有權和開發 {#ip-ownership} + +知識產權 (IP) 是傳統科學的一個大問題：從被困在大學或閒置在生物技術公司中，乃至難以估值。 然而，Web3 使用[非同質化代幣 (NFT)](/nft/)解決數位資產（例如科學數據或文章）的所有權，這是 Web3 非常擅長的。 + +就像非同質化代幣可以將未來交易的收入返還給原創作者一樣，你可以建立透明的價值歸屬鏈來獎勵研究人員、管理機構（如去中心化自治組織），甚至是資料被收集的研究對象。 + +[IP-NFT](https://medium.com/molecule-blog/ip-nfts-for-researchers-a-new-biomedical-funding-paradigm-91312d8d92e6) 還是將正在進行的實驗之資料庫去中心化的關鍵，還可以插入非同質化代幣與 [DeFi](/defi/) 金融化（從資產分割到借貸池與價值評估）。 它還允許如 [VitaDAO](https://www.vitadao.com/) 這樣的去中心化自治組織等鏈上原生實體直接在鏈上進行研究。 不可轉移的[「靈魂綁定」代幣](https://vitalik.ca/general/2022/01/26/soulbound.html)的出現，允許個人證明他們的經驗和證書與他們的以太坊地址相關聯，因而也可能在去中心化科研中發揮重要作用。 + +### 資料存儲、存取和架構 {#data-storage} + +使用 Web3 模式可使人們更容易獲得科學資料，分佈式儲存使研究能在災難性事件中倖存下來。 + +起點必須是任何持有適當可驗證憑證的去中心化身分都可以訪問的系統。 這使得敏感資料能夠被可信方安全地複製，從而避免冗餘、抵抗審查，還能重現結果，並實現多方協作與添加新資料至資料集的能力。 [compute-to-data](https://7wdata.be/predictive-analytics/compute-to-data-using-blockchain-to-decentralize-data-science-and-ai-with-the-ocean-protocol) 等機密運算方法提供了替代性存取機制，為最敏感的資料建立了可靠的研究環境。 可靠的研究環境[被 NHS 引用](https://medium.com/weavechain/whats-in-store-for-the-future-of-healthcare-data-b6398745fbbb)作為面向未來的資料隱私和協作解決方案，它開創了一個生態系統，在這個生態系統中，研究人員可以使用標準化環境來安全地處理現場資料，以共享程式碼和實踐方式。 + +靈活的 Web3 資料處理方案支持上述情況，並為真正的開放科學奠定基礎，研究人員可以在沒有存取權限且不必支付費用的情況下為公共利益貢獻一己之力。 星際檔案系統、Arweave 和 Filecoin 等 Web3 公共資料處理方案專為去中心化進行了改良。 例如，dClimate 讓所有人都能獲得氣候和天氣數據，包括來自氣象站和預測氣候模型的數據。 + +## 參與 {#get-involved} + +探索各項計畫並加入去中心化科研社群 + +- [DeSci.Global：全球活動和聚會行事曆](https://desci.global) +- [Blockchain for Science Telegram](https://t.me/BlockchainForScience) +- [Molecule：資助你的研究計畫或為其募資](https://discover.molecule.to/) +- [VitaDAO：藉由受贊助的長壽研究協議獲得資金](https://www.vitadao.com/) +- [ResearchHub：發布科學成果並與同行交流](https://www.researchhub.com/) +- [LabDAO：在電腦中折疊蛋白質](https://alphafodl.vercel.app/) +- [dClimate API：查詢去中心化社群收集的氣候數據](https://api.dclimate.net/) +- [DeSci Foundation：去中心化科研發表工具生成器](https://descifoundation.org/) +- [DeSci.World：供使用者查看、參與去中心化科研的單一窗口](https://desci.world) +- [Fleming Protocol：推動協作生物醫學發現的開源式資料經濟](https://medium.com/@FlemingProtocol/a-data-economy-for-patient-driven-biomedical-innovation-9d56bf63d3dd) +- [OceanDAO：管理資料相關科學資金的去中心化自治組織](https://oceanprotocol.com/dao) +- [Opscientia：開放的去中心化科研工作流程](https://opsci.io/research/) +- [LabDAO：在電腦中折疊蛋白質](https://alphafodl.vercel.app/) +- [Bio.xyz：為你的生物技術去中心化自治組織或去中心化科研項目募資](https://www.molecule.to/) +- [ResearchHub：發布科學成果並與同行交流](https://www.researchhub.com/) +- [VitaDAO：藉由受贊助的長壽研究協議獲得資金](https://www.vitadao.com/) +- [Fleming Protocol：推動協作生物醫學發現的開源式資料經濟](https://medium.com/@FlemingProtocol/a-data-economy-for-patient-driven-biomedical-innovation-9d56bf63d3dd) +- [主動推論實驗室](https://www.activeinference.org/) +- [CureDAO：社群所有的精準健康平台](https://docs.curedao.org/) +- [IdeaMarkets：實現去中心化的科學可信度](https://ideamarket.io/) + +歡迎補充新計畫 - 請先查看我們的[列表政策](/contributing/adding-desci-projects/)！ + +## 延伸閱讀 {#further-reading} + +- [由 Jocelynn Pearl 和 Ultrarare 撰寫的去中心化科研維基](https://docs.google.com/document/d/1aQC6zn-eXflSmpts0XGE7CawbUEHwnL6o-OFXO52PTc/edit#) +- [Jocelynn Pearl 為 a16z future 編寫的去中心化生物技術指南](https://future.a16z.com/a-guide-to-decentralized-biotech/) +- [去中心化科研的重要性](https://gitcoin.co/blog/desci-the-case-for-decentralised-science/) +- [去中心化科研指南](https://future.com/what-is-decentralized-science-aka-desci/) +- [去中心化科研資源](https://www.vincentweisser.com/decentralized-science) +- [Molecule 的生物製藥 IP-NFT - 技術性說明](https://molecule.to/blog/molecules-biopharma-ip-nfts-a-technical-description) +- [建立無需信任機制的科學系統 作者：Jon Starr](https://medium.com/@jringo/building-systems-of-trustless-science-1cd2d072f673) +- [生物技術去中心化自治組織的湧現](https://molecule.to/blog/the-emergence-of-biotech-daos) +- [Paul Kohlhaas - DeSci：去中心化科研的未來（播客）](https://anchor.fm/andrew-steinwold/episodes/Paul-Kohlhaas---DeSci-The-Future-of-Decentralized-Science---Zima-Red-ep-117-e1h683a) +- [一種去中心化科研的主動推論本體論：從情境式意義建構到知識共同體](https://zenodo.org/record/6320575) +- [去中心化科研：研究領域的未來　作者：Samuel Akinosho](https://lucidsamuel.medium.com/desci-the-future-of-research-b76cfc88c8ec) +- [科研融資（跋：去中心化科研與全新加密原語） 作者：Nadia](https://nadia.xyz/science-funding) +- [去中心化風潮正在擾亂藥物研發](https://medium.com/id-theory/decentralisation-is-disrupting-drug-development-28b5ba5d447f) + +### 影片 {#videos} + +- [去中心化科研是什麼？](https://www.youtube.com/watch?v=-DeMklVWNdA) +- [Vitalik Buterin 與科學家 Aubrey de Grey 關於長壽研究與加密貨幣之互動的討論](https://www.youtube.com/watch?v=x9TSJK1widA) +- [科學研究發表已毀。 Web3 能夠有所幫助嗎？](https://www.youtube.com/watch?v=WkvzYgCvWj8) +- [Juan Benet - 去中心化科研、獨立實驗室與大規模數據科學](https://www.youtube.com/watch?v=zkXM9H90g_E) +- [Sebastian Brunemeier - 去中心化科研如何能夠轉化生物醫學研究與創業投資](https://www.youtube.com/watch?v=qB4Tc3FcVbM) diff --git a/src/content/translations/zh-tw/social-networks/index.md b/src/content/translations/zh-tw/social-networks/index.md index 068926c569e..a679b00579d 100644 --- a/src/content/translations/zh-tw/social-networks/index.md +++ b/src/content/translations/zh-tw/social-networks/index.md @@ -79,7 +79,7 @@ Reddit 擁有[回饋式社群積分](https://cointelegraph.com/news/reddit-to-re 該程式現已上線，使用[運行名為「Moons」的社群積分版本](https://www.reddit.com/r/CryptoCurrency/wiki/moons_wiki)的 r/CryptoCurrency subreddit。 根據官方描述，Moons“會為對 subreddit 做出貢獻的發佈者、評論者、修改者提供獎勵。” 由於這些代幣位於區塊鏈上（使用者通過錢包接收），他們獨立於 Reddit 且不會丟失。 -在 Rinkeby 測試網進行初步測試後，Reddit 社群積分現已位於 [Arbitrum Nova](https://nova.arbitrum.io/)。Arbitrum Nova 是一個集合了 [validium](/developers/docs/scaling/validium/) 資產和[樂觀卷軸](/developers/docs/scaling/optimistic-rollups/)的區塊鏈。 除使用社群積分來解鎖特殊功能外，使用者亦可以在交易所用它們來換取法定貨幣。 此外，使用者擁有社群積分的數量決定了他們在社群決策過程中的影響力。 +在 Rinkeby 測試網進行初步測試後，Reddit 社群積分現已整合至 [Arbitrum Nova](https://nova.arbitrum.io/)。Arbitrum Nova 是一條集合了[側鏈](/developers/docs/scaling/sidechains/)和[樂觀卷軸](/developers/docs/scaling/optimistic-rollups/)屬性的區塊鏈。 除使用社群積分來解鎖特殊功能外，使用者亦可以在交易所用它們來換取法定貨幣。 此外，使用者擁有社群積分的數量決定了他們在社群決策過程中的影響力。 ### Twitter {#twitter} @@ -87,23 +87,26 @@ Reddit 擁有[回饋式社群積分](https://cointelegraph.com/news/reddit-to-re ### Instagram {#instagram} -2022 年 5 月，[Instagram 宣布支援以太坊上的非同質化代幣](https://about.instagram.com/blog/announcements/instagram-digital-collectibles)和 Polygon。 使用者可以透過連接他們的以太坊錢包將非同質化代幣直接發佈到 Instagram。 +2022 年 5 月，[Instagram 宣布支援以太坊和 Polygon 上的非同質化代幣](https://about.instagram.com/blog/announcements/instagram-digital-collectibles)。 使用者可以透過連接他們的以太坊錢包將非同質化代幣直接發佈到 Instagram。 ## 使用去中心化社交網路 {#use-decentralized-social-networks} -- **[Status.im](https://status.im/)** - _ Status 是安全的訊息傳遞應用程式，使用開放程式碼、點對點協定和端到端加密來保護您的訊息免受第三方的侵害。_ +- **[Status.im](https://status.im/)** - _ Status 是安全的訊息傳遞應用程式，使用開放程式碼、點對點協議和端到端加密來保護你的訊息免受第三方的侵害。_ - **[Mirror.xyz](https://mirror.xyz/)** - _Ｍ irror 是一個基於以太坊構建的使用者擁有的去中心化發布平台，供使用者眾籌創意、將內容貨幣化並建立高價值社群。_ - **[Lens Protocol](https://lens.xyz/)** - _Lens Protocol 是一個可組合和去中心化的社交圖譜，可幫助創作者在去中心化網際網路的數位花園中的任何地方擁有自己的內容。_ +- **[Farcaster](https://farcaster.xyz/)** - _Farcaster 是一個充分去中心化的社交網路。 它是個支持多種用戶端的開放式協議，如電子郵件。_ ## 延伸閱讀 {#further-reading} ### 文章 {#articles} +- [去中心化社群媒體：Web3 社交技巧指南](https://www.coinbase.com/blog/decentralizing-social-media-a-guide-to-the-web3-social-stack) - _Coinbase Ventures_ - [社交網路是下一個大的去中心化機會](https://www.coindesk.com/tech/2021/01/22/social-networks-are-the-next-big-decentralization-opportunity/) — _Ben Goertzel_ - [Web3 承諾實現由社群推動的去中心化社交網路](https://venturebeat.com/2022/02/26/web3-holds-the-promise-of-decentralized-community-powered-social-networks/) — _Sumit Ghosh_ - [區塊鏈社交媒體發展形勢概覽](https://www.gemini.com/cryptopedia/blockchain-social-media-decentralized-social-media) — _Gemini Cryptopedia_ - [區塊鏈如何解決社交媒體隱私問題](https://www.investopedia.com/news/ethereum-blockchain-social-media-privacy-problem-linkedin-indorse/) — _Prableen Bajpai_ - [社交媒體網路正在進入區塊鏈](https://businesstechguides.co/what-are-decentralized-social-networks) — _Emmanuel Awosika_ +- [社交網絡的充分去中心化](https://www.varunsrinivasan.com/2022/01/11/sufficient-decentralization-for-social-networks) — _Varun Srinivasan_ ### 影片 {#videos} diff --git a/src/content/translations/zh/community/online/index.md b/src/content/translations/zh/community/online/index.md index c132f1df5ea..972f3a99881 100644 --- a/src/content/translations/zh/community/online/index.md +++ b/src/content/translations/zh/community/online/index.md @@ -26,9 +26,9 @@ lang: zh CryptoDevs - 关注以太坊发展的 Discord 社区 EthStaker Discord - 专注于为以太坊开发提供项目管理支持的社区 Ethereum.org 网站团队 - 拜访社区中的团队和成员并与他们讨论 ethereum.org 的网络开发和设计 -Matos Discord - web3 创作者社区，构建者、业界人士和以太坊爱好者在这里聚会。 我们热衷于 Web3 的开发、设计和文化。 我们一起来构建。 -Solidity Gitter - Solidity 开发相关聊天 (Gitter) -Solidity Matrix - Solidity 开发相关聊天 (Matrix) +Matos Discord - Web3 创作者社区，构建者、业界人士和以太坊爱好者在这里聚会。 我们热衷于 Web3 的开发、设计和文化。 来吧，我们一起来构建。 +Solidity Gitter - 有关 Solidity 开发的聊天 (Gitter) +Solidity Matrix - 有关 Solidity 开发的聊天 (Matrix) 以太坊堆栈交易所 _- 问答论坛_ Peeranha _- 去中心化问答论坛_ diff --git a/src/content/translations/zh/community/support/index.md b/src/content/translations/zh/community/support/index.md index 24f6bf7c548..f395a8deda0 100644 --- a/src/content/translations/zh/community/support/index.md +++ b/src/content/translations/zh/community/support/index.md @@ -38,10 +38,11 @@ _这并不是完整的列表。 需要帮助寻找特定钱包的支持？ 加 构建这类应用可能很困难。 以下提供了一些专注于开发的平台，其中有经验丰富的以太坊开发人员，他们会乐意提供帮助。 +- [Alchemy University](https://university.alchemy.com/#starter_code) - [CryptoDevs discord](https://discord.gg/Z9TA39m8Yu) -- [以太坊 StackExchange](https://ethereum.stackexchange.com/) +- [以太坊堆栈交易所](https://ethereum.stackexchange.com/) - [StackOverflow](https://stackoverflow.com/questions/tagged/web3) -- [Web3 大学](https://www.web3.university/) +- [Web3 University](https://www.web3.university/) 您还可以在我们的[以太坊开发者资源](/developers/)部分找到文档和开发指南。 diff --git a/src/content/translations/zh/decentralized-identity/index.md b/src/content/translations/zh/decentralized-identity/index.md index 60c4c1628c9..1736de8852d 100644 --- a/src/content/translations/zh/decentralized-identity/index.md +++ b/src/content/translations/zh/decentralized-identity/index.md @@ -157,6 +157,7 @@ summaryPoint3: 多亏了加密技术，用户现在拥有了再次发布、持 - **[以太坊域名服务 (ENS)](https://ens.domains/)** - _用于链上机器可读标识（例如以太坊钱包地址、内容哈希和元数据）的去中心化命名系统。_ - **[SpruceID](https://www.spruceid.com/)** - _去中心化身份项目允许用户使用以太坊账户和以太坊域名服务配置文件来控制数字身份，而不是依赖第三方服务。_ +- **[以太坊认证服务 (EAS)](https://attest.sh/)** - _一个去中心化的账本/协议，用于进行各类链上或链下认证。_ - **[非机器人证明](https://www.proofofhumanity.id)** - _非机器人证明 (PoH) 是在以太坊上建立的社会身份验证系统。_ - **[BrightID](https://www.brightid.org/)** - _一个去中心化的开源社交身份网络，旨在通过创建和分析社交图谱来改进身份验证。_ - **[人格证明护照](https://proofofpersonhood.com/)** - _一个去中心化数字身份聚合模块。_ diff --git a/src/content/translations/zh/developers/docs/apis/javascript/index.md b/src/content/translations/zh/developers/docs/apis/javascript/index.md index b13f7c2c665..c9b8ed1f840 100644 --- a/src/content/translations/zh/developers/docs/apis/javascript/index.md +++ b/src/content/translations/zh/developers/docs/apis/javascript/index.md @@ -10,7 +10,7 @@ lang: zh 如果您想要用 JavaScript 连接到一个以太坊节点， 可以使用原生 JavaScript，不过生态系统中存在一些方便的库，使得这个事情变得更加容易。 通过这些库，开发者可以写下直观易懂甚至单行的代码就能初始化与以太坊的互动（背后使用 JSON RPC 请求）。 -请注意，自从[合并](/roadmap/merge/)以来，运行一个节点需要两个连接的以太坊软件 - 一个执行客户端和一个共识客户端。 请确保你的节点同时包含执行客户端和共识客户端。 如果你的节点不在本地计算机上（例如，你的节点在 AWS 实例上运行），请相应地更新教程中的 IP 地址。 有关更多信息，请参阅我们关于[运行节点](/developers/docs/nodes-and-clients/run-a-node/)的页面。 +请注意，[合并](/roadmap/merge/)后，运行节点需要两种互联的以太坊软件 - 执行客户端和共识客户端。 请确保你的节点同时包含执行客户端和共识客户端。 如果你的节点不在本地计算机上（例如，你的节点在 AWS 实例上运行），请相应地更新教程中的 IP 地址。 有关更多信息，请参阅我们关于[运行节点](/developers/docs/nodes-and-clients/run-a-node/)的页面。 ## 前提条件 {#prerequisites} diff --git a/src/content/translations/zh/developers/docs/apis/json-rpc/index.md b/src/content/translations/zh/developers/docs/apis/json-rpc/index.md index a68d95c77d9..653a7837616 100644 --- a/src/content/translations/zh/developers/docs/apis/json-rpc/index.md +++ b/src/content/translations/zh/developers/docs/apis/json-rpc/index.md @@ -1,12 +1,12 @@ --- title: JSON-RPC 应用程序接口 -description: 用于以太坊客户端的无状态、轻量级远程过程调用协议。 +description: 面向以太坊客户端的无状态、轻量级远程过程调用 (RPC) 协议。 lang: zh --- 为了让软件应用程序与以太坊区块链交互（通过读取区块链数据或向网络发送交易），它必须连接到以太坊节点。 -为此目的，每个[以太坊客户端](/developers/docs/nodes-and-clients/#execution-clients)都实现了一项 [JSON-RPC 规范](https://github.com/ethereum/execution-apis)，因此有一套统一的方法可供应用程序依赖，无论具体的节点或客户端实现如何。 +为此，每种[以太坊客户端](/developers/docs/nodes-and-clients/#execution-clients)均实现了 [JSON-RPC 规范](https://github.com/ethereum/execution-apis)，因而应用程序可以依赖一组统一的方法，而与具体节点或客户端实现无关。 [JSON-RPC](https://www.jsonrpc.org/specification) 是一种无状态的、轻量级远程过程调用 (RPC) 协议。 它定义了一些数据结构及其处理规则。 它与传输无关，因为这些概念可以在同一进程，通过接口、超文本传输协议或许多不同的消息传递环境中使用。 它使用 JSON (RFC 4627) 作为数据格式。 @@ -22,7 +22,7 @@ lang: zh 本页主要处理以太坊执行客户端使用的 JSON-RPC 应用程序接口。 但是，共识客户端也有一个远程过程调用应用程序接口，允许用户直接从节点查询有关节点的信息、请求信标区块、信标状态和其他与共识相关的信息。 此应用程序接口记录在[信标应用程序接口网页](https://ethereum.github.io/beacon-APIs/#/)上。 -内部应用程序接口还用于节点内的客户端间通信——也就是说，它使共识客户端和执行客户端能够交换数据。 它称为“引擎应用程序接口”，相关规范可在 [Github](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md) 上找到。 +内部应用程序接口还用于节点内的客户端间通信——也就是说，它使共识客户端和执行客户端能够交换数据。 这种内部应用程序接口称为“引擎应用程序接口”，其规范见 [GitHub](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md)。 ## 执行客户端规范 {#spec} @@ -200,7 +200,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"web3_sha3","params":["0x68656c6c `String` - 当前网络 id。 -当前网络 ID 的完整列表可在 [chainlist.org](https://chainlist.org) 获得。 一些常见的网络 ID 有： `1`：以太坊主网 `2`：Morden 测试网（现已弃用） `3`：Ropsten 测试网 `4`：Rinkeby 测试网 `5`：Goerli 测试网 +当前网络 ID 的完整列表可在 [chainlist.org](https://chainlist.org) 获得。 下面是部分常见网络 ID： + +- `1`：以太坊主网 +- `5`：Goerli 测试网 +- `11155111`：Sepolia 测试网 **示例** @@ -302,9 +306,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_protocolVersion","params":[] `Object|Boolean`，具有同步状态数据的对象，或 `FALSE`（当不同步时）： -- `startingBlock`：`QUANTITY` - 导入开始的区块（只有当同步到达链头后才会重置） -- `currentBlock`：`QUANTITY` - 当前区块，同 eth_blockNumber -- `highestBlock`：`QUANTITY` - 估计的最高区块 +- `startingBlock`: `QUANTITY` - 导入开始进行的区块（只有当同步进行到其区块头时才会被重置） +- `currentBlock`: `QUANTITY` - 当前区块，同 eth_blockNumber +- `highestBlock`: `QUANTITY` - 估计的最高区块 **示例** @@ -354,6 +358,31 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":6 } ``` +## eth_chainId {#eth_chainId} + +返回链 ID，用于签署受重放攻击保护的交易。 + +**参数** + +无 + +**返回值** + +`chainId`，表示字符串的十六进制值，代表当前链 ID 的整数。 + +**示例** + +```js +// Request +curl -X POST --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":67}' +// Result +{ + "id":67, + "jsonrpc": "2.0", + "result": "0x1" +} +``` + ### eth_mining {#eth_mining} 如果客户端正在积极挖掘新区块，则返回 `true`。 @@ -456,15 +485,15 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1 ### eth_blockNumber {#eth_blocknumber} -返回最近区块的数量。 +返回最新区块的编号。 **参数** 无 -**返回值** +**返回** -`QUANTITY` - 表示客户端所在的当前区块号的整数。 +`QUANTITY` - 表示客户端所在的当前区块编号的整数。 **示例** @@ -492,7 +521,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"] ``` -**返回值** +**返回** `QUANTITY` - 表示当前余额的整数（以 wei 为单位）。 @@ -519,7 +548,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x407 2. `QUANTITY` - 表示存储位置的整数。 3. `QUANTITY|TAG` - 整数区块号，或字符串`“latest”`、`“earliest”`或`“pending”`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block) -**返回值** +**返回** `DATA` - 此存储位置的值。 @@ -536,14 +565,14 @@ contract Storage { } ``` -检索 pos0 的值很简单： +检索 pos0 的值比较简单： ```js curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"], "id": 1}' localhost:8545 {"jsonrpc":"2.0","id":1,"result":"0x00000000000000000000000000000000000000000000000000000000000004d2"} ``` -检索映射的元素更难。 映射中的元素位置通过以下方式计算： +检索映射的元素要难一些。 映射中的元素位置通过以下方式计算： ```js keccack(LeftPad32(key, 0), LeftPad32(map position, 0)) @@ -560,7 +589,7 @@ keccak( ) ``` -可以使用 web3 库自带的 geth 控制台进行计算： +可以使用 Web3 库自带的 geth 控制台进行计算： ```js > var key = "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001" @@ -569,7 +598,7 @@ undefined "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9" ``` -现在获取存储： +现在获取该存储： ```js curl -X POST --data '{"jsonrpc":"2.0", "method": "eth_getStorageAt", "params": ["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9", "latest"], "id": 1}' localhost:8545 @@ -592,7 +621,7 @@ params: [ ] ``` -**返回值** +**返回** `QUANTITY` - 表示从该地址发送的交易数量的整数。 @@ -611,7 +640,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params ### eth_getBlockTransactionCountByHash {#eth_getblocktransactioncountbyhash} -从与给定区块哈希匹配的区块返回区块中的交易数量。 +返回匹配给定区块哈希的区块中的交易数量。 **参数** @@ -621,7 +650,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] ``` -**返回值** +**返回** `QUANTITY` - 表示此区块中的交易数量的整数。 @@ -640,7 +669,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHa ### eth_getBlockTransactionCountByNumber {#eth_getblocktransactioncountbynumber} -返回与给定区块号匹配的区块中的交易数量。 +返回匹配给定区块编号的区块中的交易数量。 **参数** @@ -652,7 +681,7 @@ params: [ ] ``` -**返回值** +**返回** `QUANTITY` - 表示此区块中的交易数量的整数。 @@ -671,7 +700,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByNu ### eth_getUncleCountByBlockHash {#eth_getunclecountbyblockhash} -从与给定区块哈希匹配的区块返回区块中的叔块数。 +返回匹配给定区块哈希的区块中的叔块数量。 **参数** @@ -681,7 +710,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByNu params: ["0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"] ``` -**返回值** +**返回** `QUANTITY` - 表示此区块中的叔块数量的整数。 @@ -700,7 +729,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","p ### eth_getUncleCountByBlockNumber {#eth_getunclecountbyblocknumber} -从与给定区块号匹配的区块返回区块中的叔块数。 +返回匹配给定区块编号的区块中的叔块数量。 **参数** @@ -712,7 +741,7 @@ params: [ ] ``` -**返回值** +**返回** `QUANTITY` - 表示此区块中的叔块数量的整数。 @@ -745,7 +774,7 @@ params: [ ] ``` -**返回值** +**返回** `DATA` - 来自给定地址的代码。 @@ -766,16 +795,16 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCode","params":["0xa94f53 Sign 方法计算以太坊特定的签名：`sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`。 -通过在消息中添加前缀，可以将计算出的签名识别为以太坊特定的签名。 这可以防止恶意去中心化应用程序可以签署任意数据（例如交易）并使用签名冒充受害者的滥用行为。 +通过在消息中添加前缀，可以将计算出的签名识别为以太坊特定的签名。 这可以防止滥用行为，如恶意去中心化应用程序可以签署任意数据（例如交易）并使用签名冒充受害者。 -注意：要签名的地址必须已解锁。 +注意：签名时使用的地址必须已解锁。 **参数** 1. `DATA`，20 字节 - 地址 2. `DATA`，N 字节 - 要签名的消息 -**返回值** +**返回** `DATA`：签名 @@ -794,7 +823,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d37 ### eth_signTransaction {#eth_signtransaction} -为交易签名，该交易随后可使用 [eth_sendRawTransaction](#eth_sendrawtransaction) 提交到网络。 +为交易签名，随后可使用 [eth_sendRawTransaction](#eth_sendrawtransaction) 方法将该交易提交到网络。 **参数** @@ -803,14 +832,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sign","params":["0x9b2055d37 - `from`：`DATA`，20 字节 - 发送交易的地址。 - `to`：`DATA`，20 字节 -（创建新合约时可选）将交易定向到的地址。 - `gas`：`QUANTITY` -（可选，默认值：90000）表示为交易执行提供的燃料的整数。 它将返回未使用的燃料。 -- `gasPrice`：`QUANTITY` -（可选，默认值：待确定）表示用于每个付费燃料的 gasPrice 的整数，单位为 Wei。 -- `value`：`QUANTITY` -（可选）表示与此交易一起发送的价值的整数，单位为 Wei。 +- `gasPrice`: `QUANTITY` -（可选，默认值：待确定）表示用于每个已支付燃料的 gasPrice 的整数，单位为 Wei。 +- `value`: `QUANTITY` -（可选）表示与此交易一起发送的值的整数，单位为 Wei。 - `data`：`DATA` - 合约的编译代码或调用的方法签名和编码参数的哈希。 - `nonce`：`QUANTITY` -（可选）表示随机数的整数。 这允许覆盖你自己的使用相同随机数的待处理交易。 -**返回值** +**返回** -`DATA`，签名的交易对象。 +`DATA`，已签名的交易对象。 **示例** @@ -833,13 +862,13 @@ curl -X POST --data '{"id": 1,"jsonrpc": "2.0","method": "eth_signTransaction"," 1. `Object` - 交易对象 -- `from`：`DATA`，20 字节 - 发送交易的地址。 -- `to`：`DATA`，20 字节 -（创建新合约时可选）将交易定向到的地址。 -- `gas`：`QUANTITY` -（可选，默认值：90000）表示为交易执行提供的燃料的整数。 它将返回未使用的燃料。 -- `gasPrice`：`QUANTITY` -（可选，默认值：待确定）表示用于每个付费燃料的 gasPrice 的整数。 -- `value`：`QUANTITY` -（可选）表示与此交易一起发送的值的整数。 -- `data`：`DATA` - 合约的编译代码或调用的方法签名和编码参数的哈希。 -- `nonce`：`QUANTITY` -（可选）表示随机数的整数。 这允许覆盖你自己的使用相同随机数的待处理交易。 +- `from`: `DATA`，20 字节 - 发送交易的地址。 +- `to`: `DATA`，20 字节 -（创建新合约时可选）将交易定向到的地址。 +- `gas`: `QUANTITY` -（可选，默认值：90000）表示为交易执行提供的燃料的整数。 它将返回未使用的燃料。 +- `gasPrice`: `QUANTITY` -（可选，默认值：待确定）表示用于每个已支付燃料的 gasPrice 的整数。 +- `value`: `QUANTITY` -（可选）表示与此交易一起发送的值的整数。 +- `data`: `DATA` - 合约的编译代码或调用的方法签名和编码参数的哈希。 +- `nonce`: `QUANTITY` -（可选）表示随机数的整数。 它允许覆盖你自己的使用相同随机数的待处理交易。 ```js params: [ @@ -889,9 +918,9 @@ params: [ **返回值** -`DATA`，32 字节 - 交易哈希，如果交易尚不可用，则为零哈希。 +`DATA`，32 字节 - 交易哈希，或者如果交易尚不可用，则为零哈希。 -当你创建合约时，交易被挖掘后，使用 [eth_getTransactionReceipt](#eth_gettransactionreceipt) 获取合约地址。 +创建合约时，在交易被挖掘后，使用 [eth_getTransactionReceipt](#eth_gettransactionreceipt) 获取合约地址。 **示例** @@ -914,12 +943,12 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params" 1. `Object` - 交易调用对象 -- `from`：`DATA`，20 字节 -（可选）发送交易的地址。 -- `to`：`DATA`，20 字节 - 将交易定向到的地址。 -- `gas`：`QUANTITY` -（可选）表示为交易执行提供的燃料的整数。 eth_call 消耗零燃料，但某些执行可能需要此参数。 -- `gasPrice`：`QUANTITY` -（可选）表示用于每个付费燃料的 gasPrice 的整数。 -- `value`：`QUANTITY` -（可选）表示与此交易一起发送的值的整数。 -- `data`：`DATA` - （可选）方法签名和编码参数的哈希。 有关详细信息，请参阅 [Solidity 文档中的以太坊合约应用程序二进制接口](https://docs.soliditylang.org/en/latest/abi-spec.html) +- `from`: `DATA`，20 字节 -（可选）发送交易的地址。 +- `to`: `DATA`，20 字节 - 将交易定向到的地址。 +- `gas`: `QUANTITY` -（可选）表示为交易执行提供的燃料的整数。 eth_call 消耗零燃料，但某些执行可能需要此参数。 +- `gasPrice`: `QUANTITY` -（可选）表示用于每个已支付燃料的 gasPrice 的整数 +- `value`: `QUANTITY` -（可选）表示与此交易一起发送的值的整数 +- `data`: `DATA` -（可选）方法签名和编码参数的哈希。 有关详细信息，参见 [Solidity 文档中的以太坊合约应用程序二进制接口](https://docs.soliditylang.org/en/latest/abi-spec.html) 2. `QUANTITY|TAG` - 整数区块号，或字符串`“latest”`、`“earliest”`或`“pending”`，参见[默认区块参数](/developers/docs/apis/json-rpc/#default-block) @@ -942,13 +971,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{see above}] ### eth_estimateGas {#eth_estimategas} -生成并返回允许交易完成所需燃料数量的估算值。 交易不会被添加到区块链中。 请注意，出于各种原因，包括以太坊虚拟机机制和节点性能，估算值可能远远超过交易实际使用的燃料数量。 +生成并返回允许交易完成所需燃料数量的估算值。 交易不会添加到区块链中。 请注意，出于各种原因，包括以太坊虚拟机机制和节点性能，估算值可能远远超过交易实际使用的燃料数量。 **参数** -参见 [eth_call](#eth_call) 参数，但所有属性都是可选的。 如果没有指定燃料限制，geth 将使用来自待处理区块的区块燃料限制作为上限。 因此，当所需燃料数量高于待处理区块的燃料限制时，返回的估算数量可能不足以执行调用/交易。 +参见 [eth_call](#eth_call) 的参数，但所有属性都是可选的。 如果没有指定燃料限制，geth 将使用来自待处理区块的区块燃料限制作为上限。 因此，当所需燃料数量高于待处理区块的燃料限制时，返回的估算值可能不足以执行调用/交易。 -**返回值** +**返回** `QUANTITY` - 使用的燃料数量。 @@ -981,29 +1010,29 @@ params: [ ] ``` -**返回值** +**返回** `Object` - 区块对象，或 `null`（当没有找到区块时）： -- `number`：`QUANTITY` - 区块编号。 当它是待处理区块时，则为 `null`。 -- `hash`：`DATA`，32 字节 - 区块的哈希。 当它是待处理区块时，则为 `null`。 -- `parentHash`：`DATA`，32 字节 - 父区块的哈希。 -- `nonce`：`DATA`，8 字节 - 已生成的工作量证明的哈希。 当它是待处理区块时，则为 `null`。 -- `sha3Uncles`：`DATA`，32 字节 - 区块中的叔块数据的 SHA3。 -- `logsBloom`：`DATA`，256 字节 - 区块日志的 bloom 过滤器。 当它是待处理区块时，则为 `null`。 -- `transactionsRoot`：`DATA`，32 字节 - 区块交易前缀树的根。 -- `stateRoot`：`DATA`，32 字节 - 区块最终状态前缀树的根。 -- `receiptsRoot`：`DATA`，32 字节 - 区块收据前缀树的根。 -- `miner`：`DATA`，20 字节 - 获得挖矿奖励的受益人地址。 -- `difficulty`：`QUANTITY` - 表示此区块难度的整数。 -- `totalDifficulty`：`QUANTITY` - 表示直到此区块为止链的总难度的整数。 -- `extraData`：`DATA` - 此区块的“额外数据”字段。 -- `size`：`QUANTITY` - 表示此区块大小的整数，以字节为单位。 -- `gasLimit`：`QUANTITY` - 此区块允许的最大燃料值。 -- `gasUsed`：`QUANTITY` - 此区块中所有交易使用的总燃料量。 -- `timestamp`：`QUANTITY` - 整理区块时的 unix 时间戳。 -- `transactions`：`Array` - 交易对象数组，或 32 字节交易哈希，取决于最后一个给定的参数。 -- `uncles`：`Array` - 叔块哈希数组。 +- `number`: `QUANTITY` - 区块编号。 如果是待处理区块，则为 `null`。 +- `hash`: `DATA`，32 字节 - 区块的哈希。 如果是待处理区块，则为 `null`。 +- `parentHash`: `DATA`，32 字节 - 父块的哈希。 +- `nonce`: `DATA`，8 字节 - 已生成的工作量证明的哈希。 如果是待处理区块，则为 `null`。 +- `sha3Uncles`: `DATA`，32 字节 - 区块中的叔块数据的 SHA3。 +- `logsBloom`: `DATA`，256 字节 - 区块日志的布隆过滤器。 如果是待处理区块，则为 `null`。 +- `transactionsRoot`: `DATA`，32 字节 - 区块交易树的根。 +- `stateRoot`: `DATA`，32 字节 - 区块最终状态树的根。 +- `receiptsRoot`: `DATA`，32 字节 - 区块收据树的根。 +- `miner`: `DATA`，20 字节 - 获得挖矿奖励的受益人的地址。 +- `difficulty`: `QUANTITY` - 表示此区块难度的整数。 +- `totalDifficulty`: `QUANTITY` - 表示到此区块为止链的总难度的整数。 +- `extraData`: `DATA` - 此区块的“额外数据”字段。 +- `size`: `QUANTITY` - 表示此区块大小的整数，以字节为单位。 +- `gasLimit`: `QUANTITY` - 此区块允许的最大燃料数量。 +- `gasUsed`: `QUANTITY` - 此区块中所有交易使用的总燃料数量。 +- `timestamp`: `QUANTITY` - 整理区块时的 unix 时间戳。 +- `transactions`: `Array` - 交易对象数组，或 32 字节交易哈希，取决于最后一个给定的参数。 +- `uncles`: `Array` - 叔块哈希数组。 **示例** @@ -1044,7 +1073,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0 ### eth_getBlockByNumber {#eth_getblockbynumber} -根据区块号返回关于区块的信息。 +根据区块编号返回关于区块的信息。 **参数** @@ -1071,7 +1100,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[ ### eth_getTransactionByHash {#eth_gettransactionbyhash} -根据交易哈希返回关于所请求交易的信息。 +返回关于按交易哈希请求的交易的信息。 **参数** @@ -1081,24 +1110,24 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[ params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"] ``` -**返回值** +**返回** -`Object` - 交易对象，如果没有找到交易，则为 `null`： - -- `blockHash`：`DATA`，32 字节 - 此交易所在区块的哈希。 当它是待处理区块时，则为 `null`。 -- `blockNumber`：`QUANTITY` - 此交易所在的区块号。 当它是待处理区块时，则为 `null`。 -- `from`：`DATA`，20 字节 - 发送者的地址。 -- `gas`：`QUANTITY` - 发送者提供的燃料。 -- `gasPrice`：`QUANTITY` - 发送者提供的燃料价格，以 Wei 为单位。 -- `hash`：`DATA`，32 字节 - 交易的哈希。 -- `input`：`DATA` - 与交易一起发送的数据。 -- `nonce`：`QUANTITY` - 发送者在此交易之前进行的交易数量。 -- `to`：`DATA`，20 字节 - 接收者的地址。 当它是合约创建交易时，则为 `null`。 -- `transactionIndex`：`QUANTITY` - 表示区块中的交易索引位置的整数。 当它是待处理区块时，则为 `null`。 -- `value`：`QUANTITY` - 传输的价值，以 Wei 为单位。 -- `v`：`QUANTITY` - ECDSA 恢复 ID -- `r`：`QUANTITY` - ECDSA 签名 r -- `s`：`QUANTITY` - ECDSA 签名 s +`Object` - 交易对象，或者如果没有找到交易，则为 `null`： + +- `blockHash`: `DATA`，32 字节 - 此交易所在区块的哈希。 如果是待处理区块，则为 `null`。 +- `blockNumber`: `QUANTITY` - 此交易所在区块的区块编号。 如果是待处理区块，则为 `null`。 +- `from`: `DATA`，20 字节 - 发送者的地址。 +- `gas`: `QUANTITY` - 发送者提供的燃料。 +- `gasPrice`: `QUANTITY` - 发送者提供的燃料价格，以 Wei 为单位。 +- `hash`: `DATA`，32 字节 - 交易的哈希。 +- `input`: `DATA` - 与交易一起发送的数据。 +- `nonce`: `QUANTITY` - 发送者在此交易之前进行的交易数量。 +- `to`: `DATA`，20 字节 - 接收者的地址。 如果是合约创建交易，则为 `null`。 +- `transactionIndex`: `QUANTITY` - 表示区块中的交易索引位置的整数。 如果是待处理区块，则为 `null`。 +- `value`: `QUANTITY` - 传输的值，以 Wei 为单位。 +- `v`: `QUANTITY` - 椭圆曲线数字签名算法恢复 ID +- `r`: `QUANTITY` - 椭圆曲线数字签名算法签名 r +- `s`: `QUANTITY` - 椭圆曲线数字签名算法签名 s **示例** @@ -1196,22 +1225,22 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getTransactionByBlockNumberA params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"] ``` -**返回值** `Object` - 交易收据对象，如果没有找到收据，则为 `null`： +**返回值** `Object` - 交易收据对象，或者如果没有找到收据，则为 `null`： -- `transactionHash`：`DATA`，32 字节- 交易的哈希。 -- `transactionIndex`：`QUANTITY` - 表示区块中的交易索引位置的整数。 -- `blockHash`：`DATA`，32 字节 - 此交易所在区块的哈希。 -- `blockNumber`：`QUANTITY` - 此交易所在的区块号。 -- `from`：`DATA`，20 字节 - 发送者的地址。 -- `to`：`DATA`，20 字节 - 接收者的地址。 当它是合约创建交易时，则为 null。 +- `transactionHash`: `DATA`，32 字节- 交易的哈希。 +- `transactionIndex`: `QUANTITY` - 表示区块中的交易索引位置的整数。 +- `blockHash`: `DATA`，32 字节 - 此交易所在区块的哈希。 +- `blockNumber`: `QUANTITY` - 此交易所在区块的区块编号。 +- `from`: `DATA`，20 字节 - 发送者的地址。 +- `to`: `DATA`，20 字节 - 接收者的地址。 如果是合约创建交易，则为 null。 - `cumulativeGasUsed` : `QUANTITY` - 当在区块中执行此交易时使用的燃料总量。 -- `effectiveGasPrice` : `QUANTITY` - 为每单位燃料支付的基础费用和小费的总和。 +- `effectiveGasPrice` : `QUANTITY` - 为每单位燃料支付的基础费和小费的总和。 - `gasUsed`: `QUANTITY` - 仅此特定交易使用的燃料数量。 -- `contractAddress`: `DATA`，20 字节 - 如果交易是创建合约，则为创建的合约地址，否则为 `null`。 +- `contractAddress`: `DATA`，20 字节 - 如果交易是创建合约的，则为创建的合约地址，否则为 `null`。 - `logs`: `Array` - 此交易生成的日志对象数组。 - `logsBloom`: `DATA`，256 字节 - 轻客户端用于快速检索相关日志的布隆过滤器。 -- `type`: `DATA` - 表示交易类型的整数，`0x00` 表示传统交易，`0x01` 表示访问列表类型，`0x02` 表示动态费用。 它还返回*以下两者之一*： -- `root` : `DATA`，32 字节的交易后状态根（拜占庭之前） +- `type`: `QUANTITY` - 表示交易类型的整数，`0x0` 表示以前的交易，`0x1` 表示访问列表类型，`0x2` 表示动态费用。 它还返回*以下两者之一*： +- `root` : `DATA`，32 字节的交易后状态根（拜占庭升级之前） - `status`: `QUANTITY`，`1`（成功）或 `0`（失败） **示例** @@ -1273,7 +1302,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockHashAndIndex" 结果参见 [eth_getBlockByHash](#eth_getblockbyhash) -**注意**：叔区不包含个人交易。 +**注意**：叔块不包含个人交易。 ### eth_getUncleByBlockNumberAndIndex {#eth_getunclebyblocknumberandindex} @@ -1293,7 +1322,7 @@ params: [ **返回值** 参见 [eth_getBlockByHash](#eth_getblockbyhash) -**注意**：叔区不包含个人交易。 +**注意**：叔块不包含个人交易。 **示例** @@ -1306,7 +1335,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getUncleByBlockNumberAndInde ### eth_getCompilers {#eth_getcompilers} -返回客户端中的可用编译器列表。 +返回客户端上的可用编译器列表。 **参数** 无 @@ -1327,7 +1356,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getCompilers","params":[],"i ### eth_compileSolidity {#eth_compile_solidity} -返回已编译的 solidity 代码。 +返回已编译的 Solidity 代码。 **参数** @@ -1415,7 +1444,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileLLL","params":["(retu ### eth_compileSerpent {#eth_compileserpent} -返回已编译的 serpent 代码。 +返回已编译的 Serpent 代码。 **参数** @@ -1444,7 +1473,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileSerpent","params":["/ 基于过滤器选项创建一个过滤器对象，以在状态更改（日志）时发出通知。 要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。 -**关于指定主题过滤器的说明：** 主题是顺序相关的。 日志中包含主题 [A, B] 的交易将被以下主题过滤器匹配： +**关于指定主题过滤器的说明：** 主题是顺序相关的。 以下主题过滤器将匹配日志中包含主题 [A, B] 的交易： - `[]`“任意值” - `[A]`“第一个位置为 A（之后的位置为任意值）” @@ -1455,10 +1484,10 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_compileSerpent","params":["/ 1. `Object` - 过滤器选项： -- `fromBlock`：`QUANTITY|TAG` -（可选，默认值：`“latest”`）整数区块号，`“latest”`（对于最后开采的区块），或`“pending”`、`“earliest”`（对于尚未开采的交易）。 -- `toBlock`：`QUANTITY|TAG` -（可选，默认值：`“latest”`）整数区块号，`“latest”`（对于最后开采的区块），或`“pending”`、`“earliest”`（对于尚未开采的交易）。 -- `address`：`DATA|Array`，20 字节 -（可选）日志起源的合同地址或地址列表。 -- `topics`：`Array of DATA` -（可选）32 字节 `DATA` 主题数组。 主题是顺序相关的。 每个主题也可以是带有“或”选项的 DATA 数组。 +- `fromBlock`: `QUANTITY|TAG` - （可选，默认值：`"latest"`）整数区块编号，或者如果是最后一个开采的区块，则为 `"latest"`，如果是尚未开采的交易，则为 `"pending"`, `"earliest"`。 +- `toBlock`: `QUANTITY|TAG` -（可选，默认值：`"latest"`）整数区块编号，或者如果是最后一个开采的区块，则为 `"latest"`，如果是尚未开采的交易，则为 `"pending"`, `"earliest"`。 +- `address`: `DATA|Array`，20 字节 -（可选）生成日志的合约地址或地址列表。 +- `topics`: `Array of DATA`, -（可选）32 字节 `DATA` 主题的数组。 主题是顺序相关的。 每个主题也可以是带有“or”选项的 DATA 数组。 ```js params: [ @@ -1478,7 +1507,7 @@ params: [ ] ``` -**返回值** `QUANTITY` - 过滤器 id。 +**返回值** `QUANTITY` - 过滤器 ID。 **示例** @@ -1495,7 +1524,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newFilter","params":[{"topic ### eth_newBlockFilter {#eth_newblockfilter} -在节点中创建一个过滤器，以在新区块到达时通知。 要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。 +在节点中创建一个过滤器，以在新区块到达时发出通知。 要检查状态是否已更改，请调用 [eth_getFilterChanges](#eth_getfilterchanges)。 **参数** 无 @@ -1537,7 +1566,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_newPendingTransactionFilter" ### eth_uninstallFilter {#eth_uninstallfilter} -卸载具有给定 ID 的过滤器。 当不再需要监控时应始终调用。 此外，过滤器在一段时间内未使用 [eth_getFilterChanges](#eth_getfilterchanges) 请求时便会超时。 +卸载具有给定 ID 的过滤器。 当不再需要监控时应始终调用该方法。 此外，在一段时间内未使用 [eth_getFilterChanges](#eth_getfilterchanges) 请求过滤器时，过滤器便会超时。 **参数** @@ -1566,7 +1595,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_uninstallFilter","params":[" ### eth_getFilterChanges {#eth_getfilterchanges} -过滤器的轮询方法，它会返回自上次轮询以来发生的日志数组。 +过滤器的轮询方法，会返回自上次轮询以来产生的日志数组。 **参数** @@ -1578,20 +1607,20 @@ params: [ ] ``` -**返回值** `Array` - 日志对象数组，如果自上次轮询以来没有任何变化，则为空数组。 +**返回值** `Array` - 日志对象数组，或者如果自上次轮询以来没有任何更改，则为空数组。 - 对于使用 `eth_newBlockFilter` 创建的过滤器，返回值是区块哈希（`DATA`，32 字节），例如 `["0x3454645634534..."]`。 - 对于使用 `eth_newPendingTransactionFilter` 创建的过滤器，返回值是交易哈希（`DATA`，32 字节），例如 `["0x6345343454645..."]`。 - 对于使用 `eth_newFilter` 创建的过滤器，日志是具有以下参数的对象： - - `removed`：`TAG` - 当日志被删除时，由于链重组，为 `true`。 当它是有效日志时，则为 `false`。 - - `logIndex`：`QUANTITY` - 表示日志在区块中的索引位置的整数。 当它是待处理日志时，则为 `null`。 - - `transactionIndex`：`QUANTITY` - 表示从中创建日志的交易索引位置的整数。 当它是待处理日志时，则为 `null`。 - - `transactionHash`：`DATA`，32 字节 - 从中创建此日志的交易的哈希。 当它是待处理日志时，则为 `null`。 - - `blockHash`: `DATA`，32 字节 - 此日志所在区块的哈希。 当它是待处理区块时，则为 `null`。 当它是待处理日志时，则为 `null`。 - - `blockNumber`：`QUANTITY` - 该日志所在的区块编号。 当它是待处理区块时，则为 `null`。 当它是待处理日志时，则为 `null`。 - - `address`：`DATA`，20 字节 - 此日志的来源地址。 - - `data`：`DATA` - 包含日志的一个或多个 32 字节非索引参数。 - - `topics`：`Array of DATA` - 0 到 4 个 32 字节 `DATA` 索引日志参数的数组。 （在 _solidity_ 中：第一个主题是事件签名的*哈希*（例如 `Deposit (address,bytes32,uint256)`），除非您使用 `anonymous` 限定符声明了该事件）。 + - `removed`: `TAG` - 当日志由于链重组被删除时，为 `true`。 如果是有效日志，则为 `false`。 + - `logIndex`: `QUANTITY` - 表示区块中的日志索引位置的整数。 如果是待处理日志，则为 `null`。 + - `transactionIndex`: `QUANTITY` -表示从中创建日志的交易索引位置的整数。 如果是待处理日志，则为 `null`。 + - `transactionHash`: `DATA`，32 字节 - 从中创建此日志的交易的哈希。 如果是待处理日志，则为 `null`。 + - `blockHash`: `DATA`，32 字节 - 此日志所在区块的哈希。 如果是待处理区块，则为 `null`。 如果是待处理日志，则为 `null`。 + - `blockNumber`: `QUANTITY` - 此日志所在区块的区块编号。 如果是待处理区块，则为 `null`。 如果是待处理日志，则为 `null`。 + - `address`: `DATA`，20 字节 - 此日志的来源地址。 + - `data`: `DATA` - 包含日志的一个或多个 32 字节非索引参数。 + - `topics`: `Array of DATA` - 0 到 4 个 32 字节 `DATA` 类型的索引日志参数的数组。 （在 _Solidity_ 中：第一个主题是事件签名的*哈希*（例如 `Deposit (address,bytes32,uint256)`），除非你使用 `anonymous` 说明符声明了该事件）。 - **示例** ```js @@ -1618,7 +1647,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterChanges","params":[ ### eth_getFilterLogs {#eth_getfilterlogs} -返回与给定 id 的过滤器匹配的所有日志的数组。 +返回与给定 ID 的过滤器匹配的所有日志的数组。 **参数** @@ -1649,11 +1678,11 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getFilterLogs","params":["0x 1. `Object` - 过滤器选项： -- `fromBlock`：`QUANTITY|TAG` -（可选，默认值：`“latest”`）整数区块号，`“latest”`（对于最后开采的区块），或`“pending”`、`“earliest”`（对于尚未开采的交易）。 -- `toBlock`：`QUANTITY|TAG` -（可选，默认值：`“latest”`）整数区块号，`“latest”`（对于最后开采的区块），或`“pending”`、`“earliest”`（对于尚未开采的交易）。 -- `address`：`DATA|Array`，20 字节 -（可选）日志起源的合同地址或地址列表。 -- `topics`：`Array of DATA` -（可选）32 字节 `DATA` 主题数组。 主题是顺序相关的。 每个主题也可以是带有“或”选项的 DATA 数组。 -- `blockhash`：`DATA`，32 字节 -（可选，**future**）添加 EIP-234 后，`blockHash` 将是一个新的过滤器选项，它会将返回的日志限制为具有 32 字节哈希 `blockHash` 的单一区块。 使用 `blockHash` 相当于 `fromBlock` = `toBlock` = 具有哈希`blockHash` 的区块号。 如果 `blockHash` 出现在筛选条件中，则 `fromBlock` 和 `toBlock` 都不允许。 +- `fromBlock`: `QUANTITY|TAG` - （可选，默认值：`"latest"`）整数区块编号，或者如果是最后一个开采的区块，则为 `"latest"`，如果是尚未开采的交易，则为 `"pending"`, `"earliest"`。 +- `toBlock`: `QUANTITY|TAG` -（可选，默认值：`"latest"`）整数区块编号，或者如果是最后一个开采的区块，则为 `"latest"`，如果是尚未开采的交易，则为 `"pending"`, `"earliest"`。 +- `address`: `DATA|Array`，20 字节 -（可选）生成日志的合约地址或地址列表。 +- `topics`: `Array of DATA`, -（可选）32 字节 `DATA` 主题的数组。 主题是顺序相关的。 每个主题也可以是带有“or”选项的 DATA 数组。 +- `blockhash`: `DATA`，32 字节 -（可选，**future**），添加 EIP-234 后，`blockHash` 将是一个新的过滤器选项，它会将返回的日志限制为具有 32 字节哈希 `blockHash` 的单一区块。 使用 `blockHash` 相当于 `fromBlock` = `toBlock` = 具有哈希`blockHash` 的区块编号。 如果 `blockHash` 出现在筛选条件中，则 `fromBlock` 和 `toBlock` 都不允许。 ```js params: [ @@ -1682,7 +1711,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics" **参数** 无 -**返回** `Array` - 具有以下属性的数组： +**返回值** `Array` - 具有以下属性的数组： 1. `DATA`，32 字符 - 当前区块头 pow-hash 2. `DATA`，32 字节 - 用于有向无环图的种子哈希。 @@ -1707,7 +1736,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getWork","params":[],"id":73 ### eth_submitWork {#eth_submitwork} -用于提交工作量证明解。 +用于提交工作证明解决方案。 **参数** @@ -1723,7 +1752,7 @@ params: [ ] ``` -**返回值** `Boolean` - 如果提供的解有效，则返回 `true`，否则返回 `false`。 +**返回值** `Boolean` - 如果提供的解决方案有效，则返回 `true`，否则返回 `false`。 **示例** @@ -1887,13 +1916,13 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"db_getHex","params":["testDB","m ### shh_version (deprecated) {#shh_post} -返回当前的 whisper 协议版本。 +返回当前的 Whisper 协议版本。 **注意**：此方法已弃用。 **参数** 无 -**返回值** `String` - 当前的 whisper 协议版本 +**返回值** `String` - 当前的 Whisper 协议版本 **示例** @@ -1910,7 +1939,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_version","params":[],"id":67 ### shh_post (deprecated) {#shh_version} -发送 whisper 消息。 +发送 Whisper 消息。 **注意**：此方法已弃用。 @@ -1918,12 +1947,12 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_version","params":[],"id":67 1. `Object` - whisper post 对象： -- `from`：`DATA`，60 字节 -（可选）发送者的身份。 -- `to`：`DATA`，60 字节 -（可选）接收者的身份。 当存在消息时，whisper 将加密消息，以便只有接收者可以将其解密。 -- `topics`：`Array of DATA` - `DATA` 主题数组，供接收者识别消息。 -- `payload`：`DATA` - 消息的载荷。 -- `priority`：`QUANTITY` - 表示 ... (?) 范围内的优先级的整数。 -- `ttl`：`QUANTITY` - 表示生存时间的整数，以秒为单位。 +- `from`: `DATA`，60 字节 -（可选）发送者的身份。 +- `to`: `DATA`，60 字节 -（可选）接收者的身份。 当存在消息时，Whisper 将加密消息，以便只有接收者可以将其解密。 +- `topics`: `Array of DATA` - `DATA` 主题的数组，供接收者识别消息。 +- `payload`: `DATA` - 消息的有效载荷。 +- `priority`: `QUANTITY` - 表示 ... (?) 范围内的优先级的整数。 +- `ttl`: `QUANTITY` - 表示生存时间的整数，以秒为单位。 ```js params: [ @@ -1958,7 +1987,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_post","params":[{"from":"0xc ### shh_newIdentity (deprecated){#shh_newidentity} -在客户端中创建新的 whisper 身份。 +在客户端中创建新的 Whisper 身份。 **注意**：此方法已弃用。 @@ -2045,7 +2074,7 @@ params: [ ] ``` -**返回值** `Boolean` - 如果身份已成功添加到组，则返回 `true`，否则返回 `false` (?)。 +**返回值** `Boolean` - 如果身份已成功添加到组中，则返回 `true`，否则返回 `false` (?)。 **示例** @@ -2062,14 +2091,14 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_addToGroup","params":["0x04f ### shh_newFilter (deprecated){#shh_newfilter} -创建过滤器以通知客户端何时收到与过滤器选项匹配的 whisper 消息。 **注意**：此方法已弃用。 +创建过滤器以通知客户端何时收到与过滤器选项匹配的 Whisper 消息。 **注意**：此方法已弃用。 **参数** 1. `Object` - 过滤器选项： -- `to`：`DATA`，60 字节 -（可选）接收者的身份。 _如果客户端持有此身份的私钥，它将尝试解密任何传入的消息。_ -- `topics`: `Array of DATA` - `DATA` 主题的数组，该主题应与传入消息的主题相匹配。 You can use the following combinations: +- `to`: `DATA`，60 字节 -（可选）接收者的身份。 _存在该身份时，如果客户端持有此身份的私钥，它将尝试解密任何传入的消息。_ +- `topics`: `Array of DATA` - `DATA` 主题的数组，传入消息的主题应与其相匹配。 可以使用下列组合： - `[A, B] = A && B` - `[A, [B, C]] = A && (B || C)` - `[null, A, B] = ANYTHING && A && B` `null` 用作通配符 @@ -2101,7 +2130,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_newFilter","params":[{"topic ### shh_uninstallFilter (deprecated){#shh_uninstallfilter} -卸载具有给定 id 的过滤器。 当不再需要监控时应始终调用。 此外，过滤器在一段时间内未使用 [shh_getFilterChanges](#shh_getfilterchanges) 请求时会超时。 **注意**：此方法已弃用。 +卸载具有给定 ID 的过滤器。 当不再需要监控时应始终调用该方法。 此外，在一段时间内未使用 [shh_getFilterChanges](#shh_getfilterchanges) 请求过滤器时，过滤器便会超时。 **注意**：此方法已弃用。 **参数** @@ -2130,7 +2159,7 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_uninstallFilter","params":[" ### shh_getFilterChanges (deprecated){#shh_getfilterchanges} -Whisper 过滤器的轮询方法。 返回自上次调用此方法以来的新消息。 **注意**：调用 [shh_getMessages](#shh_getmessages) 方法将重置此方法的缓冲区，这样您就不会收到重复的消息。 **注意**：此方法已弃用。 +Whisper 过滤器的轮询方法。 返回自上次调用此方法以来的新消息。 **注意**：调用 [shh_getMessages](#shh_getmessages) 方法将重置此方法的缓冲区，这样你就不会收到重复的消息。 **注意**：此方法已弃用。 **参数** @@ -2144,15 +2173,15 @@ params: [ **返回值** `Array` - 自上次轮询以来收到的消息数组： -- `hash`：`DATA`，32 字节(?) - 消息的哈希。 -- `from`：`DATA`，60 字节 - 如果指定了发送者，则为消息的发送者。 -- `to`：`DATA`，60 字节- 如果指定了接收者，则为消息的接收者。 -- `expiry`：`QUANTITY` - 表示此消息应到期的时间（以秒为单位）的整数 (?)。 -- `ttl`：`QUANTITY` - 表示消息应在系统中浮动的时间（以秒为单位）的整数 (?)。 -- `sent`：`QUANTITY` - 表示发送消息时的 unix 时间戳的整数。 -- `topics`：`Array of DATA` - 消息中包含的 `DATA` 主题数组。 -- `payload`：`DATA` - 消息的载荷。 -- `workProved`：`QUANTITY` - 表示发送此消息之前所需工作的整数 (?)。 +- `hash`: `DATA`，32 字节(?) - 消息的哈希。 +- `from`: `DATA`，60 字节 - 如果指定了发送者，则为消息的发送者。 +- `to`: `DATA`，60 字节- 如果指定了接收者，则为消息的接收者。 +- `expiry`: `QUANTITY` - 表示此消息应到期的时间（以秒为单位）的整数 (?)。 +- `ttl`: `QUANTITY` - 表示消息应在系统中浮动的时间（以秒为单位）的整数 (?)。 +- `sent`: `QUANTITY` - 表示发送消息时的 unix 时间戳的整数。 +- `topics`: `Array of DATA` - 消息中包含的 `DATA` 主题数组。 +- `payload`: `DATA` - 消息的有效载荷。 +- `workProved`: `QUANTITY` - 表示发送此消息之前所需工作的整数 (?)。 **示例** @@ -2209,9 +2238,9 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"shh_getMessages","params":["0x7" ### 使用 JSON_RPC 部署合约 {#deploying-contract} -本节包含如何仅使用远程过程调用接口部署合约的演示。 部署合约的其他途径可以消除这种复杂性 — 例如，使用在远程过程调用接口之上构建的库，如 [web3.js](https://web3js.readthedocs.io/) 和 [web3.py](https://github.com/ethereum/web3.py)。 这些抽象通常更容易理解且不易出错，但了解幕后发生的操作仍然很有帮助。 +本节演示如何仅使用远程过程调用接口部署合约。 其他部署合约的途径可以消除这种复杂性 — 例如，使用在远程过程调用接口之上构建的库，如 [web3.js](https://web3js.readthedocs.io/) 和 [web3.py](https://github.com/ethereum/web3.py)。 这些抽象通常更容易理解且不易出错，但了解幕后发生的操作仍然很有帮助。 -以下是一个名为 `Multiply7` 的简单智能合约，它将使用 JSON-RPC 接口部署到以太坊节点。 本教程假设读者已经在运行 Geth 节点。 [此处](/developers/docs/nodes-and-clients/run-a-node)提供了有关节点和客户端的更多信息。 请参阅单独的[客户端](/developers/docs/nodes-and-clients/)文档，了解如何为非 Geth 客户端启动超文本传输协议 JSON-RPC。 大多数客户端默认在 `localhost:8545` 上提供服务。 +以下是一个名为 `Multiply7` 的简单智能合约，将使用 JSON-RPC 接口将其部署到以太坊节点。 本教程假设读者已经在运行 Geth 节点。 [此处](/developers/docs/nodes-and-clients/run-a-node)提供了更多关于节点和客户端的信息。 请参阅单独的[客户端](/developers/docs/nodes-and-clients/)文档，了解如何为非 Geth 客户端启动超文本传输协议 JSON-RPC。 大多数客户端默认在 `localhost:8545` 上提供服务。 ```javascript contract Multiply7 { @@ -2223,7 +2252,7 @@ contract Multiply7 { } ``` -首先要做的是确保启用了超文本传输协议远程过程调用接口。 这意味着我们在启动时为 Geth 提供 `--http` 标志。 在此示例中，我们使用私有开发链上的 Geth 节点。 使用这种方法，我们在真实网络上不需要以太币。 +首先确保启用了超文本传输协议远程过程调用接口。 这意味着我们在启动时为 Geth 提供 `--http` 标志。 在此示例中，我们使用私有开发链上的 Geth 节点。 使用这种方法，我们在真实网络上不需要以太币。 ```bash geth --http --dev console 2>>geth.log @@ -2231,7 +2260,7 @@ geth --http --dev console 2>>geth.log 这将在 `http://localhost:8545` 上启动超文本传输协议远程过程调用接口。 -我们可以通过使用 [curl](https://curl.se) 检索 Coinbase 地址和余额来验证接口是否正在运行。 请注意，这些示例中的数据在您的本地节点上会有所不同。 如果你想尝试这些命令，请将第二个 curl 请求中的请求参数替换为第一个 curl 请求返回的结果。 +我们可以通过使用 [curl](https://curl.se) 检索 Coinbase 地址和余额来验证接口是否正在运行。 请注意，这些示例中的数据在你的本地节点上会有所不同。 如果你想尝试这些命令，请将第二个 curl 请求中的请求参数替换为第一个 curl 请求返回的结果。 ```bash curl --data '{"jsonrpc":"2.0","method":"eth_coinbase", "id":1}' -H "Content-Type: application/json" localhost:8545 @@ -2241,14 +2270,14 @@ curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635 {"id":2,"jsonrpc":"2.0","result":"0x1639e49bba16280000"} ``` -因为数字是十六进制编码的，所以余额以十六进制字符串返回（以 wei 为单位）。 如果我们想要获得数字形式的以太币余额，我们可以使用 Geth 控制台中的 web3。 +因为数字是十六进制编码的，所以余额以十六进制字符串返回（以 wei 为单位）。 如果我们想要获得数字形式的以太币余额，我们可以使用 Geth 控制台中的 Web3。 ```javascript web3.fromWei("0x1639e49bba16280000", "ether") // "410" ``` -现在我们的私有开发链上有一些以太币，我们可以部署合约了。 第一步是将 Multiply7 合约编译为可以发送到以太坊虚拟机的字节码。 要安装 Solidity 编译器 solc，请遵循 [Solidity 文档](https://docs.soliditylang.org/en/latest/installing-solidity.html)。 （您可能希望使用较旧的 `solc` 版本来匹配[在我们的示例中使用的编译器版本](https://github.com/ethereum/solidity/releases/tag/v0.4.20)）。 +现在我们的私有开发链上有一些以太币，我们可以部署合约了。 第一步是将 Multiply7 合约编译为可以发送到以太坊虚拟机的字节码。 要安装 Solidity 编译器 solc，请遵循 [Solidity 文档](https://docs.soliditylang.org/en/latest/installing-solidity.html)。 （你可能希望使用较旧的 `solc` 版本来匹配[在我们的示例中使用的编译器版本](https://github.com/ethereum/solidity/releases/tag/v0.4.20)。） 下一步是将 Multiply7 合约编译为可以发送到以太坊虚拟机的字节码。 @@ -2260,36 +2289,36 @@ Binary: 6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029 ``` -现在我们有了编译后的代码，我们需要确定部署它需要花费多少燃料。 远程过程调用接口有一个 `eth_estimateGas` 方法，可以给我们一个估计值。 +现在我们有了编译后的代码，我们需要确定部署它需要花费多少燃料。 远程过程调用接口有一个 `eth_estimateGas` 方法，可以给我们一个估算值。 ```bash curl --data '{"jsonrpc":"2.0","method": "eth_estimateGas", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 5}' -H "Content-Type: application/json" localhost:8545 {"jsonrpc":"2.0","id":5,"result":"0x1c31e"} ``` -最后部署合约。 +最后，部署合约。 ```bash curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from": "0x9b1d35635cc34752ca54713bb99d38614f63c955", "gas": "0x1c31e", "data": "0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029"}], "id": 6}' -H "Content-Type: application/json" localhost:8545 {"id":6,"jsonrpc":"2.0","result":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"} ``` -交易被节点接受并返回交易哈希。 此哈希可用于跟踪交易。 下一步是确定我们的合约部署的地址。 每个已执行的交易都将创建一个收据。 此收据包含有关交易的各种信息，例如交易包含在哪个区块中以及以太坊虚拟机使用了多少燃料。 如果交易创建了合约，它还将包含合约地址。 我们可以使用 `eth_getTransactionReceipt` 远程过程调用方法检索收据。 +交易被节点接受并返回交易哈希。 此哈希可用于跟踪交易。 下一步是确定部署我们的合约的地址。 每个已执行的交易都将创建一个收据。 此收据包含有关交易的各种信息，例如交易包含在哪个区块中以及以太坊虚拟机使用了多少燃料。 如果交易 创建了合约，它还将包含合约地址。 我们可以使用 `eth_getTransactionReceipt` 远程过程调用方法检索收据。 ```bash curl --data '{"jsonrpc":"2.0","method": "eth_getTransactionReceipt", "params": ["0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf"], "id": 7}' -H "Content-Type: application/json" localhost:8545 {"jsonrpc":"2.0","id":7,"result":{"blockHash":"0x77b1a4f6872b9066312de3744f60020cbd8102af68b1f6512a05b7619d527a4f","blockNumber":"0x1","contractAddress":"0x4d03d617d700cf81935d7f797f4e2ae719648262","cumulativeGasUsed":"0x1c31e","from":"0x9b1d35635cc34752ca54713bb99d38614f63c955","gasUsed":"0x1c31e","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","status":"0x1","to":null,"transactionHash":"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf","transactionIndex":"0x0"}} ``` -我们的合约是在 `0x4d03d617d700cf81935d7f797f4e2ae719648262` 上创建的。 空结果而不是收据意味着交易 尚未包含在区块中。 稍等片刻，检查您的矿工是否正在运行，然后重试。 +我们的合约是在 `0x4d03d617d700cf81935d7f797f4e2ae719648262` 上创建的。 结果为空而不是收据意味着该交易 尚未包含在区块中。 稍等片刻，检查你的矿工是否正在运行，然后重试。 #### 与智能合约交互 {#interacting-with-smart-contract} -在本例中，我们将使用 `eth_sendTransaction` 将交易发送到合约的 `multiply` 方法。 +在本示例中，我们将使用 `eth_sendTransaction` 将交易发送到合约的 `multiply` 方法。 -`eth_sendTransaction` 需要几个参数，具体而言，`from`、`to` 和 `data`。 `From` 是我们帐户的公共地址，`to` 是合约地址。 `data` 参数包含有效载荷，其定义了必须调用哪个方法以及使用哪些参数。 这就是 [ABI（应用程序二进制接口）](https://docs.soliditylang.org/en/latest/abi-spec.html)发挥作用的地方。 应用程序二进制接口是一个 JSON 文件，定义了如何为以太坊虚拟机定义和编码数据。 +`eth_sendTransaction` 需要几个参数，具体而言，`from`、`to` 和 `data`。 `From` 是我们帐户的公共地址，`to` 是合约地址。 `data` 参数包含有效载荷，它定义了必须调用哪个方法以及使用哪些参数。 这就是 [ABI（应用程序二进制接口）](https://docs.soliditylang.org/en/latest/abi-spec.html)的用武之地。 应用程序二进制接口是一个 JSON 文件，它定义了如何为以太坊虚拟机定义和编码数据。 -有效载荷的字节定义了调用合约中的哪个方法。 这是 Keccak 哈希的前 4 个字节以及函数名称及其参数类型（十六进制编码）。 Multiply 函数接受一个 uint，它是 uint256 的别名。 这给我们留下了： +有效载荷的字节定义了调用合约中的哪个方法。 这是 Keccak 哈希的前 4 个字节以及函数名称及其参数类型（十六进制编码）。 Multiply 函数接受 uint，它是 uint256 的别名。 这为我们提供了： ```javascript web3.sha3("multiply(uint256)").substring(0, 10) @@ -2302,7 +2331,7 @@ web3.sha3("multiply(uint256)").substring(0, 10) 此编码为 `0000000000000000000000000000000000000000000000000000000000000006`。 -结合函数选择器和编码参数，我们的数据将是 `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`。 +结合函数选择器和编码后的参数，我们的数据将是 `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006`。 现在可以将其发送到节点： @@ -2311,7 +2340,7 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from {"id":8,"jsonrpc":"2.0","result":"0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74"} ``` -由于发送了交易，因此返回了交易哈希。 检索收据给出： +由于发送了交易，因此返回了交易哈希。 检索收据将得出： ```javascript { @@ -2335,19 +2364,19 @@ curl --data '{"jsonrpc":"2.0","method": "eth_sendTransaction", "params": [{"from } ``` -收据中包含一个日志。 此日志由以太坊虚拟机在交易执行时生成并包含在收据中。 `multiply` 函数显示 `Print` 事件在输入乘以 7 时触发。 由于 `Print` 事件的参数是 uint256，我们可以根据应用程序二进制接口规则对其进行解码，这将为我们得出预期的十进制数 42。 除了数据之外，值得注意的是，主题可用于确定哪个事件创建了日志： +收据中包含一个日志。 此日志由以太坊虚拟机在交易执行时生成并包含在收据中。 `multiply` 函数显示 `Print` 事件在输入乘以 7 时触发。 由于 `Print` 事件的参数是 uint256，我们可以根据应用程序二进制接口规则对其进行解码，这将为我们提供预期的十进制数 42。 除了数据之外，值得注意的是，主题可用于确定哪个事件创建了日志： ```javascript web3.sha3("Print(uint256)") // "24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da" ``` -这只是对一些最常见任务的简要介绍，展示了 JSON-RPC 的直接用法。 +以上只是对一些最常见任务的简要介绍，展示了 JSON-RPC 的直接用法。 ## 相关主题 {#related-topics} - [JSON-RPC 规范](http://www.jsonrpc.org/specification) - [节点和客户端](/developers/docs/nodes-and-clients/) -- [JavaScript 应用程序接口](/developers/docs/apis/javascript/) -- [后端应用程序接口](/developers/docs/apis/backend/) +- [JavaScript API](/developers/docs/apis/javascript/) +- [后端 API](/developers/docs/apis/backend/) - [执行客户端](/developers/docs/nodes-and-clients/#execution-clients) diff --git a/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/index.md b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/index.md index e651da8c410..db9f31f89ee 100644 --- a/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/index.md +++ b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/index.md @@ -5,7 +5,7 @@ lang: zh --- -工作量证明不再是以太坊共识机制的基础，这意味着挖矿已终结。 取而代之的是，以太坊将由质押了以太币的验证者保护。 你可以立即开始质押以太币。 详细了解合并、权益证明和质押。 此页面仅展示历史内容。 +工作量证明不再是以太坊共识机制的基础，这意味着挖矿已终结。 取而代之的是，以太坊将由质押了以太币的验证者保护。 你可以立即开始质押以太币。 阅读更多关于合并、权益证明和质押的信息。 此页面仅展示历史内容。 ## 前提条件 {#prerequisites} diff --git a/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md new file mode 100644 index 00000000000..20e1c3c511a --- /dev/null +++ b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto/index.md @@ -0,0 +1,334 @@ +--- +title: Dagger-Hashimoto +description: 详细了解 Dagger-Hashimoto 算法。 +lang: zh +--- + +Dagger-Hashimoto 是以太坊挖矿算法的原始研究实现和规范。 但是，Dagger-Hashimoto 已被 [Ethash](#ethash) 取代。 在 2022 年 9 月 15 日实施的[合并](/updates/merge)后，挖矿完全关闭。 此后，以太坊采用[权益证明](/developers/docs/consensus-mechanisms/pos)机制保护安全。 本页面展示与历史有关的内容，其中的信息不再与合并后的以太坊相关。 + +## 前提条件 {#prerequisites} + +为了更好地了解此页面，建议提前阅读[工作量证明共识](/developers/docs/consensus-mechanisms/pow)、[挖矿](/developers/docs/consensus-mechanisms/pow/mining)和[挖矿算法](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms)。 + +## Dagger-Hashimoto 算法 {#dagger-hashimoto} + +Dagger-Hashimoto 旨在实现两个目标： + +1. **ASIC 抗性**：为算法打造专用硬件的益处应尽可能小。 +2. **轻量级客户端可验证性**：区块应能被轻量级客户端高效验证。 + +在作出进一步修改后，我们还要具体说明如何在必要时实现第三个目标，但要以增加复杂性为代价： + +**完整链存储**：挖矿需要存储完整的区块链状态（因为以太坊状态子树的不规则结构，我们预计将有可能进行一些修改，特别是一些经常用到的合约，但我们希望尽量减少这种情况）。 + +## 有向无环图世代 {#dag-generation} + +以下算法代码将在 Python 中定义。 首先，我们定义了 `encode_int`，用于将指定精度的无符号整数封送为字符串。 同时还定义了它的逆函数。 + +```python +NUM_BITS = 512 + +def encode_int(x): + "Encode an integer x as a string of 64 characters using a big-endian scheme" + o = '' + for _ in range(NUM_BITS / 8): + o = chr(x % 256) + o + x //= 256 + return o + +def decode_int(s): + "Unencode an integer x from a string using a big-endian scheme" + x = 0 + for c in s: + x *= 256 + x += ord(c) + return x +``` + +接下来我们假设 `sha3` 是一个需要输入整数，然后输出整数的函数，而 `dbl_sha3` 是一个 double-sha3 函数；如果将此引用代码转换为实现，使用以下代码： + +```python +from pyethereum import utils +def sha3(x): + if isinstance(x, (int, long)): + x = encode_int(x) + return decode_int(utils.sha3(x)) + +def dbl_sha3(x): + if isinstance(x, (int, long)): + x = encode_int(x) + return decode_int(utils.sha3(utils.sha3(x))) +``` + +### 参数 {#parameters} + +该算法使用的参数有： + +```python +SAFE_PRIME_512 = 2**512 - 38117 # Largest Safe Prime less than 2**512 + +params = { + "n": 4000055296 * 8 // NUM_BITS, # Size of the dataset (4 Gigabytes); MUST BE MULTIPLE OF 65536 + "n_inc": 65536, # Increment in value of n per period; MUST BE MULTIPLE OF 65536 + # with epochtime=20000 gives 882 MB growth per year + "cache_size": 2500, # Size of the light client's cache (can be chosen by light + # client; not part of the algo spec) + "diff": 2**14, # Difficulty (adjusted during block evaluation) + "epochtime": 100000, # Length of an epoch in blocks (how often the dataset is updated) + "k": 1, # Number of parents of a node + "w": w, # Used for modular exponentiation hashing + "accesses": 200, # Number of dataset accesses during hashimoto + "P": SAFE_PRIME_512 # Safe Prime for hashing and random number generation +} +``` + +`P` 在这种情况下为优先选择，因此 `log₂(P)` 仅略小于 512。512 对应于我们用来代表我们数目的 512 字节。 请注意，实际上只需要存储有向无环图的后半部分，因此，实际内存要求最初为 1 GB，每年增长 441 MB。 + +### Dagger 建图 {#dagger-graph-building} + +Dagger 建图基本式的定义如下： + +```python +def produce_dag(params, seed, length): + P = params["P"] + picker = init = pow(sha3(seed), params["w"], P) + o = [init] + for i in range(1, length): + x = picker = (picker * init) % P + for _ in range(params["k"]): + x ^= o[x % i] + o.append(pow(x, params["w"], P)) + return o +``` + +基本上，建图从单个节点 `sha3(seed)` 开始，然后根据随机的先前节点按顺序添加到其他节点上。 创建一个新的节点后，将计算种子的模块化能力，以随机选择一些小于 `i` 的索引（使用上述 `x % i`），并且使用这些索引上的节点值进行计算，以产生新的 `x` 值，随后该值被提供给一个小的工作量证明函数（基于 XOR），最终在索引 `i` 生成图值。 这种特殊设计背后的基本原理是强制按顺序访问有向无环图。如果当前值未知，则无法确定要访问的下一个有向无环图的值。 最后，模幂运算会使结果更加恶化。 + +这种算法依赖于数字理论的若干结果。 讨论情况见下文附录。 + +## 轻量级客户端评估 {#light-client-evaluation} + +上述构图旨在实现图中每个节点的重构，只计算少量节点的子树，并且仅需少量的辅助内存。 请注意，当 k=1 时，子树只是一个上升到有向无环图第一个元素的值链。 + +轻量级客户端中，有向无环图的计算函数如下： + +```python +def quick_calc(params, seed, p): + w, P = params["w"], params["P"] + cache = {} + + def quick_calc_cached(p): + if p in cache: + pass + elif p == 0: + cache[p] = pow(sha3(seed), w, P) + else: + x = pow(sha3(seed), (p + 1) * w, P) + for _ in range(params["k"]): + x ^= quick_calc_cached(x % p) + cache[p] = pow(x, w, P) + return cache[p] + + return quick_calc_cached(p) +``` + +本质上，它只是对上述算法的重写，删除了计算整个有向无环图值的循环，并用递归调用或缓存查找替换了早期的节点查找。 请注意，对于 `k=1` 的情况，缓存是不必要的，尽管进一步的优化实际上预先计算了有向无环图的前几千个值，并将其作为静态缓存进行计算；有关此代码实现，请参见附录。 + +## 有向无环图的双倍缓冲 {#double-buffer} + +在完整客户端中，使用了上述公式生成的 2 个有向无环图的[_双倍缓冲_](https://wikipedia.org/wiki/Multiple_buffering)。 具体概念是，根据上述参数，每个 `epochtime` 生成一个有向无环图。 但客户端使用的并非是最新生成的有向无环图，而是前一个。 这样做的好处是，有向无环图可以随着时间的推移而被替换掉，无需包含矿工必须突然重新计算所有数据的步骤。 否则，定期的链处理可能会突然暂时放缓，并大幅提高中心化程度。 因此，在重新计算所有数据之前的几分钟时间内，存在 51% 的攻击风险。 + +要生成用于块工作计算的有向无环图集，算法如下： + +```python +def get_prevhash(n): + from pyethereum.blocks import GENESIS_PREVHASH + from pyethereum import chain_manager + if num <= 0: + return hash_to_int(GENESIS_PREVHASH) + else: + prevhash = chain_manager.index.get_block_by_number(n - 1) + return decode_int(prevhash) + +def get_seedset(params, block): + seedset = {} + seedset["back_number"] = block.number - (block.number % params["epochtime"]) + seedset["back_hash"] = get_prevhash(seedset["back_number"]) + seedset["front_number"] = max(seedset["back_number"] - params["epochtime"], 0) + seedset["front_hash"] = get_prevhash(seedset["front_number"]) + return seedset + +def get_dagsize(params, block): + return params["n"] + (block.number // params["epochtime"]) * params["n_inc"] + +def get_daggerset(params, block): + dagsz = get_dagsize(params, block) + seedset = get_seedset(params, block) + if seedset["front_hash"] <= 0: + # No back buffer is possible, just make front buffer + return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz), + "block_number": 0}} + else: + return {"front": {"dag": produce_dag(params, seedset["front_hash"], dagsz), + "block_number": seedset["front_number"]}, + "back": {"dag": produce_dag(params, seedset["back_hash"], dagsz), + "block_number": seedset["back_number"]}} +``` + +## Hashimoto {#hashimoto} + +初始 Hashimoto 旨在将区块链用作数据集，执行从区块链中选择 N 个索引的计算，收集这些索引处的交易，对这些数据执行 XOR，并返回结果哈希值。 Thaddeus Dryja 的初始算法（为了保持一致性，被转化成 Python），具体如下： + +```python +def orig_hashimoto(prev_hash, merkle_root, list_of_transactions, nonce): + hash_output_A = sha256(prev_hash + merkle_root + nonce) + txid_mix = 0 + for i in range(64): + shifted_A = hash_output_A >> i + transaction = shifted_A % len(list_of_transactions) + txid_mix ^= list_of_transactions[transaction] << i + return txid_max ^ (nonce << 192) +``` + +不幸的是，虽然 Hashimoto 被视为 RAM 硬件，但它依靠的是 256 位计算，计算量非常之大。 然而，Dagger-Hashimoto 在索引其数据集时仅使用最低有效 64 位来解决此问题。 + +```python +def hashimoto(dag, dagsize, params, header, nonce): + m = dagsize / 2 + mix = sha3(encode_int(nonce) + header) + for _ in range(params["accesses"]): + mix ^= dag[m + (mix % 2**64) % m] + return dbl_sha3(mix) +``` + +使用双 SHA3 可以实现零数据、近乎即时的预验证，仅验证是否提供了正确的中间值。 此工作量证明的外层对专用集成电路高度友好且相当薄弱，但它的存在使分布式拒绝服务变得更加困难，因为必须完成少量工作才能生成不会立即被拒绝的区块。 以下为轻量级客户端版本： + +```python +def quick_hashimoto(seed, dagsize, params, header, nonce): + m = dagsize // 2 + mix = sha3(nonce + header) + for _ in range(params["accesses"]): + mix ^= quick_calc(params, seed, m + (mix % 2**64) % m) + return dbl_sha3(mix) +``` + +## 挖矿与验证 {#mining-and-verifying} + +现在，将它们全部整合到挖矿算法中： + +```python +def mine(daggerset, params, block): + from random import randint + nonce = randint(0, 2**64) + while 1: + result = hashimoto(daggerset, get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + if result * params["diff"] < 2**256: + break + nonce += 1 + if nonce >= 2**64: + nonce = 0 + return nonce +``` + +以下为验证算法： + +```python +def verify(daggerset, params, block, nonce): + result = hashimoto(daggerset, get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + return result * params["diff"] < 2**256 +``` + +轻量级客户端的友好验证： + +```python +def light_verify(params, header, nonce): + seedset = get_seedset(params, block) + result = quick_hashimoto(seedset["front_hash"], get_dagsize(params, block), + params, decode_int(block.prevhash), nonce) + return result * params["diff"] < 2**256 +``` + +另外，请注意 Dagger-Hashimoto 对区块头有着额外的要求： + +- 为了使双层验证起效，区块头必须同时具有随机数和中间值 pre-sha3 +- 在某处，区块头必须存储当前种子集的 sha3 + +## 延伸阅读 {#further-reading} + +_还有哪些社区资源对您有所帮助？ 请编辑本页面并添加！_ + +## 附录 {#appendix} + +如前所述，用于生成有向无环图的随机数生成依赖于数论的一些结果。 Lehmer 随机数生成程序是 `picker` 变量的基础，因此我们首先确保它具有很宽的周期。 其次，只要一开始 `x ∈ [2,P-2]`，我们便能证明 `pow(x,3,P)` 不会将 `x` 映射到 `1` 或 `P-1`。 最后，我们证明 `pow(x,3,P)` 在被视为散列函数时具有较低的冲突率。 + +### Lehmer 随机数生成程序 {#lehmer-random-number} + +虽然 `produce_dag` 函数不需要生成无偏随机数，但潜在的威胁是 `seed**i % P` 只取少数几个值。 这可以为矿工识别模式提供优势。 + +为了避免这种情况，可采用数论结果。 [_安全素数_](https://en.wikipedia.org/wiki/Safe_prime)定义为素数 `P`，从而 `(P-1)/2` 也是素数。 [乘数组](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n)中 `x` 的*顺序* （乘数组 `ℤ/nℤ`）定义为最小 `m`，以使 
xᵐ mod P ≡ 1
+鉴于这些定义，我们得到： + +> 观察 1。 令 `x` 成为乘法组 `ℤ/Pℤ` 的一员，以获得安全素数 `P`。 如果 `x mod P ≠ 1 mod P` 和 `x mod P ≠ P-1 mod P`，那么 `x` 的顺序是 ` P-1` 或 `(P-1)/2`。 + +_证明_。 由于 `P` 是一个安全素数，那么根据 \[Lagrange's Theorem\]\[lagrange\]，我们得到 `x` 的顺序为 `1`、`2`、`(P-1)/2` 或 `P-1`。 + +`x` 的顺序不能是 `1`，因为根据费马小定理，我们得出： + +
xP-1 mod P ≡ 1
+ +因此，`x` 必须是 `ℤ/nℤ` 的乘法单位，并且是唯一的乘法单位。 由于我们假设 `x ≠ 1`，所以这是不可能的。 + +`x` 的顺序不能是 `2`，除非 `x = P-1`，因为这将违反 `P` 是素数的事实。 + +从以上命题中，我们可以知道，迭代 `(picker * init) % P` 的循环长度至少为 `(P-1)/2`。 这是因为我们选择 `P` 作为安全素数，强度几乎翻倍，且 `init` 处于 `[2,2**256+1]` 区间内。 鉴于强度为 `P`，我们永远不应期待源自模幂运算的周期。 + +在有向无环图中分配第一个单元时（变量标签为 `init`），我们会计算 `pow(sha3(seed) + 2, 3, P)`。 初看起来，这并不能保证结果既不是 `1` 也不是 `P-1`。 然而，既然 `P-1` 是一个安全素数，我们还提供以下额外保证，这是观察 1 的必然结果： + +> 观察 2。 令 `x` 成为乘法组 `ℤ/Pℤ` 的一员，以获得安全素数 `P`，并让 `w` 成为自然数。 如果 `x mod P ≠ 1 mod P`、`x mod P ≠ P-1 mod P`，且 `w mod P ≠ P-1 mod P`、`w mod P ≠ 0 mod P`，那么 `xʷ mod P ≠ 1 mod P` 且 `xʷ mod P ≠ P-1 mod P` + +### 模幂运算用作散列函数 {#modular-exponentiation} + +对于特定的 `P` 值和 `w` 值，函数 `pow(x, w, P)` 可能存在许多冲突。 例如，`pow(x,9,19)` 的值只能接受 `{1,18}`。 + +鉴于 `P` 为素数，可以使用以下结果，选择一个用于模幂运算哈希函数的适当 `w` 值： + +> 观察 3。 令 `P` 为素数；当且仅当用于 `ℤ/Pℤ` 中所有 `a` 和 `b` 满足以下条件时，`w` 和 `P-1` 才能为互素。 +> +>
+> `aʷ mod P ≡ bʷ mod P`，当且仅当 `a mod P ≡ b mod P` +>
+ +因此，鉴于 `P` 为素数，且 `w` 与 `P-1` 为互素，我们得出 `|{pow(x, w, P) : x ∈ ℤ}| = P`，表示散列函数具有尽可能小的冲突率。 + +在特殊情况下，`P` 是我们选择的安全素数，那么 `P-1` 仅有系数 1、2、`(P-1)/2` 和 `P-1`。 由于 `P` > 7，我们知道 3 与 `P-1` 互素，因此 `w=3` 满足上述命题。 + +## 更有效的缓存评估算法 {#cache-based-evaluation} + +```python +def quick_calc(params, seed, p): + cache = produce_dag(params, seed, params["cache_size"]) + return quick_calc_cached(cache, params, p) + +def quick_calc_cached(cache, params, p): + P = params["P"] + if p < len(cache): + return cache[p] + else: + x = pow(cache[0], p + 1, P) + for _ in range(params["k"]): + x ^= quick_calc_cached(cache, params, x % p) + return pow(x, params["w"], P) + +def quick_hashimoto(seed, dagsize, params, header, nonce): + cache = produce_dag(params, seed, params["cache_size"]) + return quick_hashimoto_cached(cache, dagsize, params, header, nonce) + +def quick_hashimoto_cached(cache, dagsize, params, header, nonce): + m = dagsize // 2 + mask = 2**64 - 1 + mix = sha3(encode_int(nonce) + header) + for _ in range(params["accesses"]): + mix ^= quick_calc_cached(cache, params, m + (mix & mask) % m) + return dbl_sha3(mix) +``` diff --git a/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md new file mode 100644 index 00000000000..5e672a7807b --- /dev/null +++ b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md @@ -0,0 +1,1014 @@ +--- +title: Ethash +description: Ethash 算法详细介绍。 +lang: zh +--- + + + Ethash 是以太坊的工作量证明挖矿算法。 工作量证明现在已经被**完全关闭**，取而代之，以太坊现在使用权益证明来保证安全。 阅读更多关于合并、权益证明和质押的信息。 此页面是为了满足对历史的兴趣！ + + +[Ethash](https://github.com/ethereum/wiki/wiki/Ethash) 是 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto) 算法的修改版。 Ethash 工作量证明是[内存密集型](https://wikipedia.org/wiki/Memory-hard_function)算法，这被认为使算法可抵御专用集成电路。 Ethash 专用集成电路最终被开发出来，但在工作量证明被关闭之前，图形处理单元挖矿仍然是一个可行的选择。 Ethash 仍然用于在其他非以太坊工作量证明网络上挖掘其他币。 + +## Ethash 是如何工作的？ {#how-does-ethash-work} + +内存硬度通过工作量证明算法实现，需要根据随机数和区块头选择固定资源子集。 该资源（大小为几 GB）称为有向无环图。 有向无环图每 30000 个区块更改一次（大约 125 小时的窗口，称为一个时段（大约 5.2 天）），需要一段时间才能生成。 由于有向无环图仅依赖于区块高度，因此可以预先生成，但如果没有，则客户端需要等到此过程结束才能生成区块。 如果客户端没有提前预生成和缓存有向无环图，网络可能会在每个时段过渡时遇到严重的区块延迟。 请注意，不需要生成有向无环图即可验证，工作量证明本质上允许使用低端中央处理器和小内存进行验证。 + +该算法采取的一般路线如下： + +1. 有一个**种子**，可以通过扫描区块头直到该点来为每个区块计算种子。 +2. 从种子中可以计算出 **16 MB 的伪随机缓存**。 轻量级客户端存储缓存。 +3. 我们可以从缓存中生成一个 **1 GB 数据集**，数据集中每个项目仅依赖于一小部分缓存中的项目。 全客户端和矿工存储数据集。 数据集随着时间的流逝而呈线性增长。 +4. 采矿会抢走数据集的随机片段并将它们散列在一起。 可以通过使用缓存来重新生成您需要的数据集中的特定区块，以较低的内存进行验证，以使您只需要存储缓存。 + +每隔 30000 个区块更新一次大数据集，因此，矿工的绝大部分工作都是读取数据集，而不是对其进行修改。 + +## 定义 {#definitions} + +我们采用以下定义： + +``` +WORD_BYTES = 4 # bytes in word +DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis +DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch +CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis +CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch +CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache +EPOCH_LENGTH = 30000 # blocks per epoch +MIX_BYTES = 128 # width of mix +HASH_BYTES = 64 # hash length in bytes +DATASET_PARENTS = 256 # number of parents of each dataset element +CACHE_ROUNDS = 3 # number of rounds in cache production +ACCESSES = 64 # number of accesses in hashimoto loop +``` + +### 使用“SHA3” {#sha3} + +以太坊的开发恰逢 SHA3 标准的制定， 标准进程对最终确定的哈希算法的填充做了后期改动，使得以太坊的 “sha3_256”和“sha3_512”哈希值不是标准的 sha3 哈希值，而是在其他情况下 常被称为“Keccak-256”和“Keccak-512”的变量。 讨论请见[此处](https://eips.ethereum.org/EIPS-1803)、[此处](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use)或[此处](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057)。 + +请记住这一点，因为下面的算法描述中提到了“sha3”哈希值。 + +## 参数 {#parameters} + +Ethash 的缓存和数据集的参数取决于区块号。 缓存大小和数据集大小都呈线性增长；然而，我们总是取低于线性增长阈值的最高素数，以降低意外规律导致循环行为的风险。 + +```python +def get_cache_size(block_number): + sz = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number // EPOCH_LENGTH) + sz -= HASH_BYTES + while not isprime(sz / HASH_BYTES): + sz -= 2 * HASH_BYTES + return sz + +def get_full_size(block_number): + sz = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number // EPOCH_LENGTH) + sz -= MIX_BYTES + while not isprime(sz / MIX_BYTES): + sz -= 2 * MIX_BYTES + return sz +``` + +附录中提供了数据集和缓存大小值表。 + +## 缓存生成 {#cache-generation} + +现在，我们来指定生成缓存的函数： + +```python +def mkcache(cache_size, seed): + n = cache_size // HASH_BYTES + + # Sequentially produce the initial dataset + o = [sha3_512(seed)] + for i in range(1, n): + o.append(sha3_512(o[-1])) + + # Use a low-round version of randmemohash + for _ in range(CACHE_ROUNDS): + for i in range(n): + v = o[i][0] % n + o[i] = sha3_512(map(xor, o[(i-1+n) % n], o[v])) + + return o +``` + +缓存生成过程中，先按顺序填充 32 MB 内存，然后从[严格内存硬哈希函数 (2014)](http://www.hashcash.org/papers/memohash.pdf) 执行两次 Sergio Demian Lerner 的 _RandMemoHash_ 算法。 输出一组 524288 个 64 字节值。 + +## 数据聚合函数 {#date-aggregation-function} + +我们使用灵感来自 [FNV 哈希](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function)的算法，在部分情况下，这种算法可用作逻辑异或的不相关替代。 请注意，我们使用全 32 位输入乘以素数，与之相对地，FNV-1 spec 用 1 个字节（8 个字节）依次乘以素数。 + +```python +FNV_PRIME = 0x01000193 + +def fnv(v1, v2): + return ((v1 * FNV_PRIME) ^ v2) % 2**32 +``` + +请注意，即使黄皮书也指出 fnv 为 v1\*(FNV_PRIME ^ v2)，所有当前实现始终采用上述定义。 + +## 完整数据集计算 {#full-dataset-calculation} + +整个 1 GB 数据集中每个 64 字节项目的计算如下： + +```python +def calc_dataset_item(cache, i): + n = len(cache) + r = HASH_BYTES // WORD_BYTES + # initialize the mix + mix = copy.copy(cache[i % n]) + mix[0] ^= i + mix = sha3_512(mix) + # fnv it with a lot of random cache nodes based on i + for j in range(DATASET_PARENTS): + cache_index = fnv(i ^ j, mix[j % r]) + mix = map(fnv, mix, cache[cache_index % n]) + return sha3_512(mix) +``` + +基本上，我们将来自 256 个伪随机选择的缓存节点的数据聚集起来求哈希值，以计算数据集节点。 然后生成整个数据集： + +```python +def calc_dataset(full_size, cache): + return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)] +``` + +## 主循环 {#main-loop} + +现在，我们指定了类似“hashimoto”的主要循环。在此循环中，我们聚合整个数据集的数据，以生成特定区块头和随机数的最终值。 在下面的代码中，`header` 代表一个*被截断*区块头的递归长度前缀表示的 SHA3-256 _哈希值_。被截断是指区块头被截去了 **mixHash** 和**随机数**字段。 `nonce` 是指一个 64 位无符号整数的八个字节，按大端序排列。 因此 `nonce[::-1]` 是上述值的八字节小端序表示： + +```python +def hashimoto(header, nonce, full_size, dataset_lookup): + n = full_size / HASH_BYTES + w = MIX_BYTES // WORD_BYTES + mixhashes = MIX_BYTES / HASH_BYTES + # combine header+nonce into a 64 byte seed + s = sha3_512(header + nonce[::-1]) + # start the mix with replicated s + mix = [] + for _ in range(MIX_BYTES / HASH_BYTES): + mix.extend(s) + # mix in random dataset nodes + for i in range(ACCESSES): + p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes + newdata = [] + for j in range(MIX_BYTES / HASH_BYTES): + newdata.extend(dataset_lookup(p + j)) + mix = map(fnv, mix, newdata) + # compress mix + cmix = [] + for i in range(0, len(mix), 4): + cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3])) + return { + "mix digest": serialize_hash(cmix), + "result": serialize_hash(sha3_256(s+cmix)) + } + +def hashimoto_light(full_size, cache, header, nonce): + return hashimoto(header, nonce, full_size, lambda x: calc_dataset_item(cache, x)) + +def hashimoto_full(full_size, dataset, header, nonce): + return hashimoto(header, nonce, full_size, lambda x: dataset[x]) +``` + +基本上，我们保持着一个宽 128 字节的“混合物”，并多次按顺序从整个数据集中获取 128 字节，并使用 `fnv` 函数将其与混合物结合起来。 使用 128 字节的序列访问，以便每轮算法总是能从随机访问内存获取完整的页面，从而尽量减少转译后备缓冲区的疏忽，而专用集成电路在理论上能够避免这些疏忽。 + +如果此算法的输出低于所需目标，即证明随机数是有效的。 请注意，在最后额外应用 `sha3_256` 将确保中间随机数的存在。提供此证据可以证明至少做了少量工作；而且此快速外部工作量证明验证可以用于反分布式拒绝服务目的。 也可提供统计保证，说明结果是一个无偏 256 位数字。 + +## 挖矿 {#mining} + +挖矿算法定义如下： + +```python +def mine(full_size, dataset, header, difficulty): + # zero-pad target to compare with hash on the same digit + target = zpad(encode_int(2**256 // difficulty), 64)[::-1] + from random import randint + nonce = randint(0, 2**64) + while hashimoto_full(full_size, dataset, header, nonce) > target: + nonce = (nonce + 1) % 2**64 + return nonce +``` + +## 定义种子哈希 {#seed-hash} + +为了计算用于在给定区块上挖掘的种子哈希值，我们使用以下算法： + +```python + def get_seedhash(block): + s = '\x00' * 32 + for i in range(block.number // EPOCH_LENGTH): + s = serialize_hash(sha3_256(s)) + return s +``` + +请注意，为了顺利挖矿和验证，我们建议在单个线程中预先计算未来的种子哈希值和数据集。 + +## 延伸阅读 {#further-reading} + +_还有哪些社区资源对您有所帮助？ 请编辑本页面并添加！_ + +## 附录 {#appendix} + +如果您有兴趣将上述 python spec 作为代码运行，则应在头部添加以下代码。 + +```python +import sha3, copy + +# Assumes little endian bit ordering (same as Intel architectures) +def decode_int(s): + return int(s[::-1].encode('hex'), 16) if s else 0 + +def encode_int(s): + a = "%x" % s + return '' if s == 0 else ('0' * (len(a) % 2) + a).decode('hex')[::-1] + +def zpad(s, length): + return s + '\x00' * max(0, length - len(s)) + +def serialize_hash(h): + return ''.join([zpad(encode_int(x), 4) for x in h]) + +def deserialize_hash(h): + return [decode_int(h[i:i+WORD_BYTES]) for i in range(0, len(h), WORD_BYTES)] + +def hash_words(h, sz, x): + if isinstance(x, list): + x = serialize_hash(x) + y = h(x) + return deserialize_hash(y) + +def serialize_cache(ds): + return ''.join([serialize_hash(h) for h in ds]) + +serialize_dataset = serialize_cache + +# sha3 hash function, outputs 64 bytes +def sha3_512(x): + return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x) + +def sha3_256(x): + return hash_words(lambda v: sha3.sha3_256(v).digest(), 32, x) + +def xor(a, b): + return a ^ b + +def isprime(x): + for i in range(2, int(x**0.5)): + if x % i == 0: + return False + return True +``` + +### 数据大小 {#data-sizes} + +以下查找表列表显示了大约 2048 个数据大小和缓存大小时段。 + +```python +def get_datasize(block_number): + return data_sizes[block_number // EPOCH_LENGTH] + +def get_cachesize(block_number): + return cache_sizes[block_number // EPOCH_LENGTH] + +data_sizes = [ +1073739904, 1082130304, 1090514816, 1098906752, 1107293056, +1115684224, 1124070016, 1132461952, 1140849536, 1149232768, +1157627776, 1166013824, 1174404736, 1182786944, 1191180416, +1199568512, 1207958912, 1216345216, 1224732032, 1233124736, +1241513344, 1249902464, 1258290304, 1266673792, 1275067264, +1283453312, 1291844992, 1300234112, 1308619904, 1317010048, +1325397376, 1333787776, 1342176128, 1350561664, 1358954368, +1367339392, 1375731584, 1384118144, 1392507008, 1400897408, +1409284736, 1417673344, 1426062464, 1434451072, 1442839168, +1451229056, 1459615616, 1468006016, 1476394112, 1484782976, +1493171584, 1501559168, 1509948032, 1518337664, 1526726528, +1535114624, 1543503488, 1551892096, 1560278656, 1568669056, +1577056384, 1585446272, 1593831296, 1602219392, 1610610304, +1619000192, 1627386752, 1635773824, 1644164224, 1652555648, +1660943488, 1669332608, 1677721216, 1686109312, 1694497664, +1702886272, 1711274624, 1719661184, 1728047744, 1736434816, +1744829056, 1753218944, 1761606272, 1769995904, 1778382464, +1786772864, 1795157888, 1803550592, 1811937664, 1820327552, +1828711552, 1837102976, 1845488768, 1853879936, 1862269312, +1870656896, 1879048064, 1887431552, 1895825024, 1904212096, +1912601216, 1920988544, 1929379456, 1937765504, 1946156672, +1954543232, 1962932096, 1971321728, 1979707264, 1988093056, +1996487552, 2004874624, 2013262208, 2021653888, 2030039936, +2038430848, 2046819968, 2055208576, 2063596672, 2071981952, +2080373632, 2088762752, 2097149056, 2105539712, 2113928576, +2122315136, 2130700672, 2139092608, 2147483264, 2155872128, +2164257664, 2172642176, 2181035392, 2189426048, 2197814912, +2206203008, 2214587264, 2222979712, 2231367808, 2239758208, +2248145024, 2256527744, 2264922752, 2273312128, 2281701248, +2290086272, 2298476672, 2306867072, 2315251072, 2323639168, +2332032128, 2340420224, 2348808064, 2357196416, 2365580416, +2373966976, 2382363008, 2390748544, 2399139968, 2407530368, +2415918976, 2424307328, 2432695424, 2441084288, 2449472384, +2457861248, 2466247808, 2474637184, 2483026816, 2491414144, +2499803776, 2508191872, 2516582272, 2524970368, 2533359232, +2541743488, 2550134144, 2558525056, 2566913408, 2575301504, +2583686528, 2592073856, 2600467328, 2608856192, 2617240448, +2625631616, 2634022016, 2642407552, 2650796416, 2659188352, +2667574912, 2675965312, 2684352896, 2692738688, 2701130624, +2709518464, 2717907328, 2726293376, 2734685056, 2743073152, +2751462016, 2759851648, 2768232832, 2776625536, 2785017728, +2793401984, 2801794432, 2810182016, 2818571648, 2826959488, +2835349376, 2843734144, 2852121472, 2860514432, 2868900992, +2877286784, 2885676928, 2894069632, 2902451584, 2910843008, +2919234688, 2927622784, 2936011648, 2944400768, 2952789376, +2961177728, 2969565568, 2977951616, 2986338944, 2994731392, +3003120256, 3011508352, 3019895936, 3028287104, 3036675968, +3045063808, 3053452928, 3061837696, 3070228352, 3078615424, +3087003776, 3095394944, 3103782272, 3112173184, 3120562048, +3128944768, 3137339264, 3145725056, 3154109312, 3162505088, +3170893184, 3179280256, 3187669376, 3196056704, 3204445568, +3212836736, 3221224064, 3229612928, 3238002304, 3246391168, +3254778496, 3263165824, 3271556224, 3279944576, 3288332416, +3296719232, 3305110912, 3313500032, 3321887104, 3330273152, +3338658944, 3347053184, 3355440512, 3363827072, 3372220288, +3380608384, 3388997504, 3397384576, 3405774208, 3414163072, +3422551936, 3430937984, 3439328384, 3447714176, 3456104576, +3464493952, 3472883584, 3481268864, 3489655168, 3498048896, +3506434432, 3514826368, 3523213952, 3531603584, 3539987072, +3548380288, 3556763264, 3565157248, 3573545344, 3581934464, +3590324096, 3598712704, 3607098752, 3615488384, 3623877248, +3632265856, 3640646528, 3649043584, 3657430144, 3665821568, +3674207872, 3682597504, 3690984832, 3699367808, 3707764352, +3716152448, 3724541056, 3732925568, 3741318016, 3749706368, +3758091136, 3766481536, 3774872704, 3783260032, 3791650432, +3800036224, 3808427648, 3816815488, 3825204608, 3833592704, +3841981568, 3850370432, 3858755968, 3867147904, 3875536256, +3883920512, 3892313728, 3900702592, 3909087872, 3917478784, +3925868416, 3934256512, 3942645376, 3951032192, 3959422336, +3967809152, 3976200064, 3984588416, 3992974976, 4001363584, +4009751168, 4018141312, 4026530432, 4034911616, 4043308928, +4051695488, 4060084352, 4068472448, 4076862848, 4085249408, +4093640576, 4102028416, 4110413696, 4118805632, 4127194496, +4135583104, 4143971968, 4152360832, 4160746112, 4169135744, +4177525888, 4185912704, 4194303616, 4202691968, 4211076736, +4219463552, 4227855488, 4236246656, 4244633728, 4253022848, +4261412224, 4269799808, 4278184832, 4286578048, 4294962304, +4303349632, 4311743104, 4320130432, 4328521088, 4336909184, +4345295488, 4353687424, 4362073472, 4370458496, 4378852736, +4387238528, 4395630208, 4404019072, 4412407424, 4420790656, +4429182848, 4437571456, 4445962112, 4454344064, 4462738048, +4471119232, 4479516544, 4487904128, 4496289664, 4504682368, +4513068416, 4521459584, 4529846144, 4538232704, 4546619776, +4555010176, 4563402112, 4571790208, 4580174464, 4588567936, +4596957056, 4605344896, 4613734016, 4622119808, 4630511488, +4638898816, 4647287936, 4655675264, 4664065664, 4672451968, +4680842624, 4689231488, 4697620352, 4706007424, 4714397056, +4722786176, 4731173248, 4739562368, 4747951744, 4756340608, +4764727936, 4773114496, 4781504384, 4789894784, 4798283648, +4806667648, 4815059584, 4823449472, 4831835776, 4840226176, +4848612224, 4857003392, 4865391488, 4873780096, 4882169728, +4890557312, 4898946944, 4907333248, 4915722368, 4924110976, +4932499328, 4940889728, 4949276032, 4957666432, 4966054784, +4974438016, 4982831488, 4991221376, 4999607168, 5007998848, +5016386432, 5024763776, 5033164672, 5041544576, 5049941888, +5058329728, 5066717056, 5075107456, 5083494272, 5091883904, +5100273536, 5108662144, 5117048192, 5125436032, 5133827456, +5142215296, 5150605184, 5158993024, 5167382144, 5175769472, +5184157568, 5192543872, 5200936064, 5209324928, 5217711232, +5226102656, 5234490496, 5242877312, 5251263872, 5259654016, +5268040832, 5276434304, 5284819328, 5293209728, 5301598592, +5309986688, 5318374784, 5326764416, 5335151488, 5343542144, +5351929472, 5360319872, 5368706944, 5377096576, 5385484928, +5393871232, 5402263424, 5410650496, 5419040384, 5427426944, +5435816576, 5444205952, 5452594816, 5460981376, 5469367936, +5477760896, 5486148736, 5494536832, 5502925952, 5511315328, +5519703424, 5528089984, 5536481152, 5544869504, 5553256064, +5561645696, 5570032768, 5578423936, 5586811264, 5595193216, +5603585408, 5611972736, 5620366208, 5628750464, 5637143936, +5645528192, 5653921408, 5662310272, 5670694784, 5679082624, +5687474048, 5695864448, 5704251008, 5712641408, 5721030272, +5729416832, 5737806208, 5746194304, 5754583936, 5762969984, +5771358592, 5779748224, 5788137856, 5796527488, 5804911232, +5813300608, 5821692544, 5830082176, 5838468992, 5846855552, +5855247488, 5863636096, 5872024448, 5880411008, 5888799872, +5897186432, 5905576832, 5913966976, 5922352768, 5930744704, +5939132288, 5947522432, 5955911296, 5964299392, 5972688256, +5981074304, 5989465472, 5997851008, 6006241408, 6014627968, +6023015552, 6031408256, 6039796096, 6048185216, 6056574848, +6064963456, 6073351808, 6081736064, 6090128768, 6098517632, +6106906496, 6115289216, 6123680896, 6132070016, 6140459648, +6148849024, 6157237376, 6165624704, 6174009728, 6182403712, +6190792064, 6199176064, 6207569792, 6215952256, 6224345216, +6232732544, 6241124224, 6249510272, 6257899136, 6266287744, +6274676864, 6283065728, 6291454336, 6299843456, 6308232064, +6316620928, 6325006208, 6333395584, 6341784704, 6350174848, +6358562176, 6366951296, 6375337856, 6383729536, 6392119168, +6400504192, 6408895616, 6417283456, 6425673344, 6434059136, +6442444672, 6450837376, 6459223424, 6467613056, 6476004224, +6484393088, 6492781952, 6501170048, 6509555072, 6517947008, +6526336384, 6534725504, 6543112832, 6551500672, 6559888768, +6568278656, 6576662912, 6585055616, 6593443456, 6601834112, +6610219648, 6618610304, 6626999168, 6635385472, 6643777408, +6652164224, 6660552832, 6668941952, 6677330048, 6685719424, +6694107776, 6702493568, 6710882176, 6719274112, 6727662976, +6736052096, 6744437632, 6752825984, 6761213824, 6769604224, +6777993856, 6786383488, 6794770816, 6803158144, 6811549312, +6819937664, 6828326528, 6836706176, 6845101696, 6853491328, +6861880448, 6870269312, 6878655104, 6887046272, 6895433344, +6903822208, 6912212864, 6920596864, 6928988288, 6937377152, +6945764992, 6954149248, 6962544256, 6970928768, 6979317376, +6987709312, 6996093824, 7004487296, 7012875392, 7021258624, +7029652352, 7038038912, 7046427776, 7054818944, 7063207808, +7071595136, 7079980928, 7088372608, 7096759424, 7105149824, +7113536896, 7121928064, 7130315392, 7138699648, 7147092352, +7155479168, 7163865728, 7172249984, 7180648064, 7189036672, +7197424768, 7205810816, 7214196608, 7222589824, 7230975104, +7239367552, 7247755904, 7256145536, 7264533376, 7272921472, +7281308032, 7289694848, 7298088832, 7306471808, 7314864512, +7323253888, 7331643008, 7340029568, 7348419712, 7356808832, +7365196672, 7373585792, 7381973888, 7390362752, 7398750592, +7407138944, 7415528576, 7423915648, 7432302208, 7440690304, +7449080192, 7457472128, 7465860992, 7474249088, 7482635648, +7491023744, 7499412608, 7507803008, 7516192384, 7524579968, +7532967296, 7541358464, 7549745792, 7558134656, 7566524032, +7574912896, 7583300992, 7591690112, 7600075136, 7608466816, +7616854912, 7625244544, 7633629824, 7642020992, 7650410368, +7658794112, 7667187328, 7675574912, 7683961984, 7692349568, +7700739712, 7709130368, 7717519232, 7725905536, 7734295424, +7742683264, 7751069056, 7759457408, 7767849088, 7776238208, +7784626816, 7793014912, 7801405312, 7809792128, 7818179968, +7826571136, 7834957184, 7843347328, 7851732352, 7860124544, +7868512384, 7876902016, 7885287808, 7893679744, 7902067072, +7910455936, 7918844288, 7927230848, 7935622784, 7944009344, +7952400256, 7960786048, 7969176704, 7977565312, 7985953408, +7994339968, 8002730368, 8011119488, 8019508096, 8027896192, +8036285056, 8044674688, 8053062272, 8061448832, 8069838464, +8078227328, 8086616704, 8095006592, 8103393664, 8111783552, +8120171392, 8128560256, 8136949376, 8145336704, 8153726848, +8162114944, 8170503296, 8178891904, 8187280768, 8195669632, +8204058496, 8212444544, 8220834176, 8229222272, 8237612672, +8246000768, 8254389376, 8262775168, 8271167104, 8279553664, +8287944064, 8296333184, 8304715136, 8313108352, 8321497984, +8329885568, 8338274432, 8346663296, 8355052928, 8363441536, +8371828352, 8380217984, 8388606592, 8396996224, 8405384576, +8413772672, 8422161536, 8430549376, 8438939008, 8447326592, +8455715456, 8464104832, 8472492928, 8480882048, 8489270656, +8497659776, 8506045312, 8514434944, 8522823808, 8531208832, +8539602304, 8547990656, 8556378752, 8564768384, 8573154176, +8581542784, 8589933952, 8598322816, 8606705024, 8615099264, +8623487872, 8631876992, 8640264064, 8648653952, 8657040256, +8665430656, 8673820544, 8682209152, 8690592128, 8698977152, +8707374464, 8715763328, 8724151424, 8732540032, 8740928384, +8749315712, 8757704576, 8766089344, 8774480768, 8782871936, +8791260032, 8799645824, 8808034432, 8816426368, 8824812928, +8833199488, 8841591424, 8849976448, 8858366336, 8866757248, +8875147136, 8883532928, 8891923328, 8900306816, 8908700288, +8917088384, 8925478784, 8933867392, 8942250368, 8950644608, +8959032704, 8967420544, 8975809664, 8984197504, 8992584064, +9000976256, 9009362048, 9017752448, 9026141312, 9034530688, +9042917504, 9051307904, 9059694208, 9068084864, 9076471424, +9084861824, 9093250688, 9101638528, 9110027648, 9118416512, +9126803584, 9135188096, 9143581312, 9151969664, 9160356224, +9168747136, 9177134464, 9185525632, 9193910144, 9202302848, +9210690688, 9219079552, 9227465344, 9235854464, 9244244864, +9252633472, 9261021824, 9269411456, 9277799296, 9286188928, +9294574208, 9302965888, 9311351936, 9319740032, 9328131968, +9336516736, 9344907392, 9353296768, 9361685888, 9370074752, +9378463616, 9386849408, 9395239808, 9403629184, 9412016512, +9420405376, 9428795008, 9437181568, 9445570688, 9453960832, +9462346624, 9470738048, 9479121536, 9487515008, 9495903616, +9504289664, 9512678528, 9521067904, 9529456256, 9537843584, +9546233728, 9554621312, 9563011456, 9571398784, 9579788672, +9588178304, 9596567168, 9604954496, 9613343104, 9621732992, +9630121856, 9638508416, 9646898816, 9655283584, 9663675776, +9672061312, 9680449664, 9688840064, 9697230464, 9705617536, +9714003584, 9722393984, 9730772608, 9739172224, 9747561088, +9755945344, 9764338816, 9772726144, 9781116544, 9789503872, +9797892992, 9806282624, 9814670464, 9823056512, 9831439232, +9839833984, 9848224384, 9856613504, 9865000576, 9873391232, +9881772416, 9890162816, 9898556288, 9906940544, 9915333248, +9923721088, 9932108672, 9940496512, 9948888448, 9957276544, +9965666176, 9974048384, 9982441088, 9990830464, 9999219584, +10007602816, 10015996544, 10024385152, 10032774016, 10041163648, +10049548928, 10057940096, 10066329472, 10074717824, 10083105152, +10091495296, 10099878784, 10108272256, 10116660608, 10125049216, +10133437312, 10141825664, 10150213504, 10158601088, 10166991232, +10175378816, 10183766144, 10192157312, 10200545408, 10208935552, +10217322112, 10225712768, 10234099328, 10242489472, 10250876032, +10259264896, 10267656064, 10276042624, 10284429184, 10292820352, +10301209472, 10309598848, 10317987712, 10326375296, 10334763392, +10343153536, 10351541632, 10359930752, 10368318592, 10376707456, +10385096576, 10393484672, 10401867136, 10410262144, 10418647424, +10427039104, 10435425664, 10443810176, 10452203648, 10460589952, +10468982144, 10477369472, 10485759104, 10494147712, 10502533504, +10510923392, 10519313536, 10527702656, 10536091264, 10544478592, +10552867712, 10561255808, 10569642368, 10578032768, 10586423168, +10594805632, 10603200128, 10611588992, 10619976064, 10628361344, +10636754048, 10645143424, 10653531776, 10661920384, 10670307968, +10678696832, 10687086464, 10695475072, 10703863168, 10712246144, +10720639616, 10729026688, 10737414784, 10745806208, 10754190976, +10762581376, 10770971264, 10779356288, 10787747456, 10796135552, +10804525184, 10812915584, 10821301888, 10829692288, 10838078336, +10846469248, 10854858368, 10863247232, 10871631488, 10880023424, +10888412032, 10896799616, 10905188992, 10913574016, 10921964672, +10930352768, 10938742912, 10947132544, 10955518592, 10963909504, +10972298368, 10980687488, 10989074816, 10997462912, 11005851776, +11014241152, 11022627712, 11031017344, 11039403904, 11047793024, +11056184704, 11064570752, 11072960896, 11081343872, 11089737856, +11098128256, 11106514816, 11114904448, 11123293568, 11131680128, +11140065152, 11148458368, 11156845696, 11165236864, 11173624192, +11182013824, 11190402688, 11198790784, 11207179136, 11215568768, +11223957376, 11232345728, 11240734592, 11249122688, 11257511296, +11265899648, 11274285952, 11282675584, 11291065472, 11299452544, +11307842432, 11316231296, 11324616832, 11333009024, 11341395584, +11349782656, 11358172288, 11366560384, 11374950016, 11383339648, +11391721856, 11400117376, 11408504192, 11416893568, 11425283456, +11433671552, 11442061184, 11450444672, 11458837888, 11467226752, +11475611776, 11484003968, 11492392064, 11500780672, 11509169024, +11517550976, 11525944448, 11534335616, 11542724224, 11551111808, +11559500672, 11567890304, 11576277376, 11584667008, 11593056128, +11601443456, 11609830016, 11618221952, 11626607488, 11634995072, +11643387776, 11651775104, 11660161664, 11668552576, 11676940928, +11685330304, 11693718656, 11702106496, 11710496128, 11718882688, +11727273088, 11735660416, 11744050048, 11752437376, 11760824704, +11769216128, 11777604736, 11785991296, 11794381952, 11802770048, +11811157888, 11819548544, 11827932544, 11836324736, 11844713344, +11853100928, 11861486464, 11869879936, 11878268032, 11886656896, +11895044992, 11903433088, 11911822976, 11920210816, 11928600448, +11936987264, 11945375872, 11953761152, 11962151296, 11970543488, +11978928512, 11987320448, 11995708288, 12004095104, 12012486272, +12020875136, 12029255552, 12037652096, 12046039168, 12054429568, +12062813824, 12071206528, 12079594624, 12087983744, 12096371072, +12104759936, 12113147264, 12121534592, 12129924992, 12138314624, +12146703232, 12155091584, 12163481216, 12171864704, 12180255872, +12188643968, 12197034112, 12205424512, 12213811328, 12222199424, +12230590336, 12238977664, 12247365248, 12255755392, 12264143488, +12272531584, 12280920448, 12289309568, 12297694592, 12306086528, +12314475392, 12322865024, 12331253632, 12339640448, 12348029312, +12356418944, 12364805248, 12373196672, 12381580928, 12389969024, +12398357632, 12406750592, 12415138432, 12423527552, 12431916416, +12440304512, 12448692352, 12457081216, 12465467776, 12473859968, +12482245504, 12490636672, 12499025536, 12507411584, 12515801728, +12524190592, 12532577152, 12540966272, 12549354368, 12557743232, +12566129536, 12574523264, 12582911872, 12591299456, 12599688064, +12608074624, 12616463488, 12624845696, 12633239936, 12641631616, +12650019968, 12658407296, 12666795136, 12675183232, 12683574656, +12691960192, 12700350592, 12708740224, 12717128576, 12725515904, +12733906816, 12742295168, 12750680192, 12759071872, 12767460736, +12775848832, 12784236928, 12792626816, 12801014656, 12809404288, +12817789312, 12826181504, 12834568832, 12842954624, 12851345792, +12859732352, 12868122496, 12876512128, 12884901248, 12893289088, +12901672832, 12910067584, 12918455168, 12926842496, 12935232896, +12943620736, 12952009856, 12960396928, 12968786816, 12977176192, +12985563776, 12993951104, 13002341504, 13010730368, 13019115392, +13027506304, 13035895168, 13044272512, 13052673152, 13061062528, +13069446272, 13077838976, 13086227072, 13094613632, 13103000192, +13111393664, 13119782528, 13128157568, 13136559232, 13144945024, +13153329536, 13161724288, 13170111872, 13178502784, 13186884736, +13195279744, 13203667072, 13212057472, 13220445824, 13228832128, +13237221248, 13245610624, 13254000512, 13262388352, 13270777472, +13279166336, 13287553408, 13295943296, 13304331904, 13312719488, +13321108096, 13329494656, 13337885824, 13346274944, 13354663808, +13363051136, 13371439232, 13379825024, 13388210816, 13396605056, +13404995456, 13413380224, 13421771392, 13430159744, 13438546048, +13446937216, 13455326848, 13463708288, 13472103808, 13480492672, +13488875648, 13497269888, 13505657728, 13514045312, 13522435712, +13530824576, 13539210112, 13547599232, 13555989376, 13564379008, +13572766336, 13581154432, 13589544832, 13597932928, 13606320512, +13614710656, 13623097472, 13631477632, 13639874944, 13648264064, +13656652928, 13665041792, 13673430656, 13681818496, 13690207616, +13698595712, 13706982272, 13715373184, 13723762048, 13732150144, +13740536704, 13748926592, 13757316224, 13765700992, 13774090112, +13782477952, 13790869376, 13799259008, 13807647872, 13816036736, +13824425344, 13832814208, 13841202304, 13849591424, 13857978752, +13866368896, 13874754688, 13883145344, 13891533184, 13899919232, +13908311168, 13916692096, 13925085056, 13933473152, 13941866368, +13950253696, 13958643584, 13967032192, 13975417216, 13983807616, +13992197504, 14000582272, 14008973696, 14017363072, 14025752192, +14034137984, 14042528384, 14050918016, 14059301504, 14067691648, +14076083584, 14084470144, 14092852352, 14101249664, 14109635968, +14118024832, 14126407552, 14134804352, 14143188608, 14151577984, +14159968384, 14168357248, 14176741504, 14185127296, 14193521024, +14201911424, 14210301824, 14218685056, 14227067264, 14235467392, +14243855488, 14252243072, 14260630144, 14269021568, 14277409408, +14285799296, 14294187904, 14302571392, 14310961792, 14319353728, +14327738752, 14336130944, 14344518784, 14352906368, 14361296512, +14369685376, 14378071424, 14386462592, 14394848128, 14403230848, +14411627392, 14420013952, 14428402304, 14436793472, 14445181568, +14453569664, 14461959808, 14470347904, 14478737024, 14487122816, +14495511424, 14503901824, 14512291712, 14520677504, 14529064832, +14537456768, 14545845632, 14554234496, 14562618496, 14571011456, +14579398784, 14587789184, 14596172672, 14604564608, 14612953984, +14621341312, 14629724288, 14638120832, 14646503296, 14654897536, +14663284864, 14671675264, 14680061056, 14688447616, 14696835968, +14705228416, 14713616768, 14722003328, 14730392192, 14738784128, +14747172736, 14755561088, 14763947648, 14772336512, 14780725376, +14789110144, 14797499776, 14805892736, 14814276992, 14822670208, +14831056256, 14839444352, 14847836032, 14856222848, 14864612992, +14872997504, 14881388672, 14889775744, 14898165376, 14906553472, +14914944896, 14923329664, 14931721856, 14940109696, 14948497024, +14956887424, 14965276544, 14973663616, 14982053248, 14990439808, +14998830976, 15007216768, 15015605888, 15023995264, 15032385152, +15040768384, 15049154944, 15057549184, 15065939072, 15074328448, +15082715008, 15091104128, 15099493504, 15107879296, 15116269184, +15124659584, 15133042304, 15141431936, 15149824384, 15158214272, +15166602368, 15174991232, 15183378304, 15191760512, 15200154496, +15208542592, 15216931712, 15225323392, 15233708416, 15242098048, +15250489216, 15258875264, 15267265408, 15275654528, 15284043136, +15292431488, 15300819584, 15309208192, 15317596544, 15325986176, +15334374784, 15342763648, 15351151744, 15359540608, 15367929728, +15376318336, 15384706432, 15393092992, 15401481856, 15409869952, +15418258816, 15426649984, 15435037568, 15443425664, 15451815296, +15460203392, 15468589184, 15476979328, 15485369216, 15493755776, +15502146944, 15510534272, 15518924416, 15527311232, 15535699072, +15544089472, 15552478336, 15560866688, 15569254528, 15577642624, +15586031488, 15594419072, 15602809472, 15611199104, 15619586432, +15627975296, 15636364928, 15644753792, 15653141888, 15661529216, +15669918848, 15678305152, 15686696576, 15695083136, 15703474048, +15711861632, 15720251264, 15728636288, 15737027456, 15745417088, +15753804928, 15762194048, 15770582656, 15778971008, 15787358336, +15795747712, 15804132224, 15812523392, 15820909696, 15829300096, +15837691264, 15846071936, 15854466944, 15862855808, 15871244672, +15879634816, 15888020608, 15896409728, 15904799104, 15913185152, +15921577088, 15929966464, 15938354816, 15946743424, 15955129472, +15963519872, 15971907968, 15980296064, 15988684928, 15997073024, +16005460864, 16013851264, 16022241152, 16030629248, 16039012736, +16047406976, 16055794816, 16064181376, 16072571264, 16080957824, +16089346688, 16097737856, 16106125184, 16114514816, 16122904192, +16131292544, 16139678848, 16148066944, 16156453504, 16164839552, +16173236096, 16181623424, 16190012032, 16198401152, 16206790528, +16215177344, 16223567744, 16231956352, 16240344704, 16248731008, +16257117824, 16265504384, 16273898624, 16282281856, 16290668672, +16299064192, 16307449216, 16315842176, 16324230016, 16332613504, +16341006464, 16349394304, 16357783168, 16366172288, 16374561664, +16382951296, 16391337856, 16399726208, 16408116352, 16416505472, +16424892032, 16433282176, 16441668224, 16450058624, 16458448768, +16466836864, 16475224448, 16483613056, 16492001408, 16500391808, +16508779648, 16517166976, 16525555328, 16533944192, 16542330752, +16550719616, 16559110528, 16567497088, 16575888512, 16584274816, +16592665472, 16601051008, 16609442944, 16617832064, 16626218624, +16634607488, 16642996096, 16651385728, 16659773824, 16668163712, +16676552576, 16684938112, 16693328768, 16701718144, 16710095488, +16718492288, 16726883968, 16735272832, 16743661184, 16752049792, +16760436608, 16768827008, 16777214336, 16785599104, 16793992832, +16802381696, 16810768768, 16819151744, 16827542656, 16835934848, +16844323712, 16852711552, 16861101952, 16869489536, 16877876864, +16886265728, 16894653056, 16903044736, 16911431296, 16919821696, +16928207488, 16936592768, 16944987776, 16953375616, 16961763968, +16970152832, 16978540928, 16986929536, 16995319168, 17003704448, +17012096896, 17020481152, 17028870784, 17037262208, 17045649536, +17054039936, 17062426496, 17070814336, 17079205504, 17087592064, +17095978112, 17104369024, 17112759424, 17121147776, 17129536384, +17137926016, 17146314368, 17154700928, 17163089792, 17171480192, +17179864192, 17188256896, 17196644992, 17205033856, 17213423488, +17221811072, 17230198912, 17238588032, 17246976896, 17255360384, +17263754624, 17272143232, 17280530048, 17288918912, 17297309312, +17305696384, 17314085504, 17322475136, 17330863744, 17339252096, +17347640192, 17356026496, 17364413824, 17372796544, 17381190016, +17389583488, 17397972608, 17406360704, 17414748544, 17423135872, +17431527296, 17439915904, 17448303232, 17456691584, 17465081728, +17473468288, 17481857408, 17490247552, 17498635904, 17507022464, +17515409024, 17523801728, 17532189824, 17540577664, 17548966016, +17557353344, 17565741184, 17574131584, 17582519168, 17590907008, +17599296128, 17607687808, 17616076672, 17624455808, 17632852352, +17641238656, 17649630848, 17658018944, 17666403968, 17674794112, +17683178368, 17691573376, 17699962496, 17708350592, 17716739968, +17725126528, 17733517184, 17741898112, 17750293888, 17758673024, +17767070336, 17775458432, 17783848832, 17792236928, 17800625536, +17809012352, 17817402752, 17825785984, 17834178944, 17842563968, +17850955648, 17859344512, 17867732864, 17876119424, 17884511872, +17892900224, 17901287296, 17909677696, 17918058112, 17926451072, +17934843776, 17943230848, 17951609216, 17960008576, 17968397696, +17976784256, 17985175424, 17993564032, 18001952128, 18010339712, +18018728576, 18027116672, 18035503232, 18043894144, 18052283264, +18060672128, 18069056384, 18077449856, 18085837184, 18094225792, +18102613376, 18111004544, 18119388544, 18127781248, 18136170368, +18144558976, 18152947328, 18161336192, 18169724288, 18178108544, +18186498944, 18194886784, 18203275648, 18211666048, 18220048768, +18228444544, 18236833408, 18245220736] + +cache_sizes = [ +16776896, 16907456, 17039296, 17170112, 17301056, 17432512, 17563072, +17693888, 17824192, 17955904, 18087488, 18218176, 18349504, 18481088, +18611392, 18742336, 18874304, 19004224, 19135936, 19267264, 19398208, +19529408, 19660096, 19791424, 19922752, 20053952, 20184896, 20315968, +20446912, 20576576, 20709184, 20840384, 20971072, 21102272, 21233216, +21364544, 21494848, 21626816, 21757376, 21887552, 22019392, 22151104, +22281536, 22412224, 22543936, 22675264, 22806464, 22935872, 23068096, +23198272, 23330752, 23459008, 23592512, 23723968, 23854912, 23986112, +24116672, 24247616, 24378688, 24509504, 24640832, 24772544, 24903488, +25034432, 25165376, 25296704, 25427392, 25558592, 25690048, 25820096, +25951936, 26081728, 26214208, 26345024, 26476096, 26606656, 26737472, +26869184, 26998208, 27131584, 27262528, 27393728, 27523904, 27655744, +27786688, 27917888, 28049344, 28179904, 28311488, 28441792, 28573504, +28700864, 28835648, 28966208, 29096768, 29228608, 29359808, 29490752, +29621824, 29752256, 29882816, 30014912, 30144448, 30273728, 30406976, +30538432, 30670784, 30799936, 30932672, 31063744, 31195072, 31325248, +31456192, 31588288, 31719232, 31850432, 31981504, 32110784, 32243392, +32372672, 32505664, 32636608, 32767808, 32897344, 33029824, 33160768, +33289664, 33423296, 33554368, 33683648, 33816512, 33947456, 34076992, +34208704, 34340032, 34471744, 34600256, 34734016, 34864576, 34993984, +35127104, 35258176, 35386688, 35518528, 35650624, 35782336, 35910976, +36044608, 36175808, 36305728, 36436672, 36568384, 36699968, 36830656, +36961984, 37093312, 37223488, 37355072, 37486528, 37617472, 37747904, +37879232, 38009792, 38141888, 38272448, 38403392, 38535104, 38660672, +38795584, 38925632, 39059264, 39190336, 39320768, 39452096, 39581632, +39713984, 39844928, 39974848, 40107968, 40238144, 40367168, 40500032, +40631744, 40762816, 40894144, 41023552, 41155904, 41286208, 41418304, +41547712, 41680448, 41811904, 41942848, 42073792, 42204992, 42334912, +42467008, 42597824, 42729152, 42860096, 42991552, 43122368, 43253696, +43382848, 43515712, 43646912, 43777088, 43907648, 44039104, 44170432, +44302144, 44433344, 44564288, 44694976, 44825152, 44956864, 45088448, +45219008, 45350464, 45481024, 45612608, 45744064, 45874496, 46006208, +46136768, 46267712, 46399424, 46529344, 46660672, 46791488, 46923328, +47053504, 47185856, 47316928, 47447872, 47579072, 47710144, 47839936, +47971648, 48103232, 48234176, 48365248, 48496192, 48627136, 48757312, +48889664, 49020736, 49149248, 49283008, 49413824, 49545152, 49675712, +49807168, 49938368, 50069056, 50200256, 50331584, 50462656, 50593472, +50724032, 50853952, 50986048, 51117632, 51248576, 51379904, 51510848, +51641792, 51773248, 51903296, 52035136, 52164032, 52297664, 52427968, +52557376, 52690112, 52821952, 52952896, 53081536, 53213504, 53344576, +53475776, 53608384, 53738816, 53870528, 54000832, 54131776, 54263744, +54394688, 54525248, 54655936, 54787904, 54918592, 55049152, 55181248, +55312064, 55442752, 55574336, 55705024, 55836224, 55967168, 56097856, +56228672, 56358592, 56490176, 56621888, 56753728, 56884928, 57015488, +57146816, 57278272, 57409216, 57540416, 57671104, 57802432, 57933632, +58064576, 58195264, 58326976, 58457408, 58588864, 58720192, 58849984, +58981696, 59113024, 59243456, 59375552, 59506624, 59637568, 59768512, +59897792, 60030016, 60161984, 60293056, 60423872, 60554432, 60683968, +60817216, 60948032, 61079488, 61209664, 61341376, 61471936, 61602752, +61733696, 61865792, 61996736, 62127808, 62259136, 62389568, 62520512, +62651584, 62781632, 62910784, 63045056, 63176128, 63307072, 63438656, +63569216, 63700928, 63831616, 63960896, 64093888, 64225088, 64355392, +64486976, 64617664, 64748608, 64879424, 65009216, 65142464, 65273792, +65402816, 65535424, 65666752, 65797696, 65927744, 66060224, 66191296, +66321344, 66453056, 66584384, 66715328, 66846656, 66977728, 67108672, +67239104, 67370432, 67501888, 67631296, 67763776, 67895104, 68026304, +68157248, 68287936, 68419264, 68548288, 68681408, 68811968, 68942912, +69074624, 69205568, 69337024, 69467584, 69599168, 69729472, 69861184, +69989824, 70122944, 70253888, 70385344, 70515904, 70647232, 70778816, +70907968, 71040832, 71171648, 71303104, 71432512, 71564992, 71695168, +71826368, 71958464, 72089536, 72219712, 72350144, 72482624, 72613568, +72744512, 72875584, 73006144, 73138112, 73268672, 73400128, 73530944, +73662272, 73793344, 73924544, 74055104, 74185792, 74316992, 74448832, +74579392, 74710976, 74841664, 74972864, 75102784, 75233344, 75364544, +75497024, 75627584, 75759296, 75890624, 76021696, 76152256, 76283072, +76414144, 76545856, 76676672, 76806976, 76937792, 77070016, 77200832, +77331392, 77462464, 77593664, 77725376, 77856448, 77987776, 78118336, +78249664, 78380992, 78511424, 78642496, 78773056, 78905152, 79033664, +79166656, 79297472, 79429568, 79560512, 79690816, 79822784, 79953472, +80084672, 80214208, 80346944, 80477632, 80608576, 80740288, 80870848, +81002048, 81133504, 81264448, 81395648, 81525952, 81657536, 81786304, +81919808, 82050112, 82181312, 82311616, 82443968, 82573376, 82705984, +82835776, 82967744, 83096768, 83230528, 83359552, 83491264, 83622464, +83753536, 83886016, 84015296, 84147776, 84277184, 84409792, 84540608, +84672064, 84803008, 84934336, 85065152, 85193792, 85326784, 85458496, +85589312, 85721024, 85851968, 85982656, 86112448, 86244416, 86370112, +86506688, 86637632, 86769344, 86900672, 87031744, 87162304, 87293632, +87424576, 87555392, 87687104, 87816896, 87947968, 88079168, 88211264, +88341824, 88473152, 88603712, 88735424, 88862912, 88996672, 89128384, +89259712, 89390272, 89521984, 89652544, 89783872, 89914816, 90045376, +90177088, 90307904, 90438848, 90569152, 90700096, 90832832, 90963776, +91093696, 91223744, 91356992, 91486784, 91618496, 91749824, 91880384, +92012224, 92143552, 92273344, 92405696, 92536768, 92666432, 92798912, +92926016, 93060544, 93192128, 93322816, 93453632, 93583936, 93715136, +93845056, 93977792, 94109504, 94240448, 94371776, 94501184, 94632896, +94764224, 94895552, 95023424, 95158208, 95287744, 95420224, 95550016, +95681216, 95811904, 95943872, 96075328, 96203584, 96337856, 96468544, +96599744, 96731072, 96860992, 96992576, 97124288, 97254848, 97385536, +97517248, 97647808, 97779392, 97910464, 98041408, 98172608, 98303168, +98434496, 98565568, 98696768, 98827328, 98958784, 99089728, 99220928, +99352384, 99482816, 99614272, 99745472, 99876416, 100007104, +100138048, 100267072, 100401088, 100529984, 100662592, 100791872, +100925248, 101056064, 101187392, 101317952, 101449408, 101580608, +101711296, 101841728, 101973824, 102104896, 102235712, 102366016, +102498112, 102628672, 102760384, 102890432, 103021888, 103153472, +103284032, 103415744, 103545152, 103677248, 103808576, 103939648, +104070976, 104201792, 104332736, 104462528, 104594752, 104725952, +104854592, 104988608, 105118912, 105247808, 105381184, 105511232, +105643072, 105774784, 105903296, 106037056, 106167872, 106298944, +106429504, 106561472, 106691392, 106822592, 106954304, 107085376, +107216576, 107346368, 107478464, 107609792, 107739712, 107872192, +108003136, 108131392, 108265408, 108396224, 108527168, 108657344, +108789568, 108920384, 109049792, 109182272, 109312576, 109444928, +109572928, 109706944, 109837888, 109969088, 110099648, 110230976, +110362432, 110492992, 110624704, 110755264, 110886208, 111017408, +111148864, 111279296, 111410752, 111541952, 111673024, 111803456, +111933632, 112066496, 112196416, 112328512, 112457792, 112590784, +112715968, 112852672, 112983616, 113114944, 113244224, 113376448, +113505472, 113639104, 113770304, 113901376, 114031552, 114163264, +114294592, 114425536, 114556864, 114687424, 114818624, 114948544, +115080512, 115212224, 115343296, 115473472, 115605184, 115736128, +115867072, 115997248, 116128576, 116260288, 116391488, 116522944, +116652992, 116784704, 116915648, 117046208, 117178304, 117308608, +117440192, 117569728, 117701824, 117833024, 117964096, 118094656, +118225984, 118357312, 118489024, 118617536, 118749632, 118882112, +119012416, 119144384, 119275328, 119406016, 119537344, 119668672, +119798464, 119928896, 120061376, 120192832, 120321728, 120454336, +120584512, 120716608, 120848192, 120979136, 121109056, 121241408, +121372352, 121502912, 121634752, 121764416, 121895744, 122027072, +122157632, 122289088, 122421184, 122550592, 122682944, 122813888, +122945344, 123075776, 123207488, 123338048, 123468736, 123600704, +123731264, 123861952, 123993664, 124124608, 124256192, 124386368, +124518208, 124649024, 124778048, 124911296, 125041088, 125173696, +125303744, 125432896, 125566912, 125696576, 125829056, 125958592, +126090304, 126221248, 126352832, 126483776, 126615232, 126746432, +126876608, 127008704, 127139392, 127270336, 127401152, 127532224, +127663552, 127794752, 127925696, 128055232, 128188096, 128319424, +128449856, 128581312, 128712256, 128843584, 128973632, 129103808, +129236288, 129365696, 129498944, 129629888, 129760832, 129892288, +130023104, 130154048, 130283968, 130416448, 130547008, 130678336, +130807616, 130939456, 131071552, 131202112, 131331776, 131464384, +131594048, 131727296, 131858368, 131987392, 132120256, 132250816, +132382528, 132513728, 132644672, 132774976, 132905792, 133038016, +133168832, 133299392, 133429312, 133562048, 133692992, 133823296, +133954624, 134086336, 134217152, 134348608, 134479808, 134607296, +134741056, 134872384, 135002944, 135134144, 135265472, 135396544, +135527872, 135659072, 135787712, 135921472, 136052416, 136182848, +136313792, 136444864, 136576448, 136707904, 136837952, 136970048, +137099584, 137232064, 137363392, 137494208, 137625536, 137755712, +137887424, 138018368, 138149824, 138280256, 138411584, 138539584, +138672832, 138804928, 138936128, 139066688, 139196864, 139328704, +139460032, 139590208, 139721024, 139852864, 139984576, 140115776, +140245696, 140376512, 140508352, 140640064, 140769856, 140902336, +141032768, 141162688, 141294016, 141426496, 141556544, 141687488, +141819584, 141949888, 142080448, 142212544, 142342336, 142474432, +142606144, 142736192, 142868288, 142997824, 143129408, 143258944, +143392448, 143523136, 143653696, 143785024, 143916992, 144045632, +144177856, 144309184, 144440768, 144570688, 144701888, 144832448, +144965056, 145096384, 145227584, 145358656, 145489856, 145620928, +145751488, 145883072, 146011456, 146144704, 146275264, 146407232, +146538176, 146668736, 146800448, 146931392, 147062336, 147193664, +147324224, 147455936, 147586624, 147717056, 147848768, 147979456, +148110784, 148242368, 148373312, 148503232, 148635584, 148766144, +148897088, 149028416, 149159488, 149290688, 149420224, 149551552, +149683136, 149814976, 149943616, 150076352, 150208064, 150338624, +150470464, 150600256, 150732224, 150862784, 150993088, 151125952, +151254976, 151388096, 151519168, 151649728, 151778752, 151911104, +152042944, 152174144, 152304704, 152435648, 152567488, 152698816, +152828992, 152960576, 153091648, 153222976, 153353792, 153484096, +153616192, 153747008, 153878336, 154008256, 154139968, 154270912, +154402624, 154533824, 154663616, 154795712, 154926272, 155057984, +155188928, 155319872, 155450816, 155580608, 155712064, 155843392, +155971136, 156106688, 156237376, 156367424, 156499264, 156630976, +156761536, 156892352, 157024064, 157155008, 157284416, 157415872, +157545536, 157677248, 157810496, 157938112, 158071744, 158203328, +158334656, 158464832, 158596288, 158727616, 158858048, 158988992, +159121216, 159252416, 159381568, 159513152, 159645632, 159776192, +159906496, 160038464, 160169536, 160300352, 160430656, 160563008, +160693952, 160822208, 160956352, 161086784, 161217344, 161349184, +161480512, 161611456, 161742272, 161873216, 162002752, 162135872, +162266432, 162397888, 162529216, 162660032, 162790976, 162922048, +163052096, 163184576, 163314752, 163446592, 163577408, 163707968, +163839296, 163969984, 164100928, 164233024, 164364224, 164494912, +164625856, 164756672, 164887616, 165019072, 165150016, 165280064, +165412672, 165543104, 165674944, 165805888, 165936832, 166067648, +166198336, 166330048, 166461248, 166591552, 166722496, 166854208, +166985408, 167116736, 167246656, 167378368, 167508416, 167641024, +167771584, 167903168, 168034112, 168164032, 168295744, 168427456, +168557632, 168688448, 168819136, 168951616, 169082176, 169213504, +169344832, 169475648, 169605952, 169738048, 169866304, 169999552, +170131264, 170262464, 170393536, 170524352, 170655424, 170782016, +170917696, 171048896, 171179072, 171310784, 171439936, 171573184, +171702976, 171835072, 171966272, 172097216, 172228288, 172359232, +172489664, 172621376, 172747712, 172883264, 173014208, 173144512, +173275072, 173407424, 173539136, 173669696, 173800768, 173931712, +174063424, 174193472, 174325696, 174455744, 174586816, 174718912, +174849728, 174977728, 175109696, 175242688, 175374272, 175504832, +175636288, 175765696, 175898432, 176028992, 176159936, 176291264, +176422592, 176552512, 176684864, 176815424, 176946496, 177076544, +177209152, 177340096, 177470528, 177600704, 177731648, 177864256, +177994816, 178126528, 178257472, 178387648, 178518464, 178650176, +178781888, 178912064, 179044288, 179174848, 179305024, 179436736, +179568448, 179698496, 179830208, 179960512, 180092608, 180223808, +180354752, 180485696, 180617152, 180748096, 180877504, 181009984, +181139264, 181272512, 181402688, 181532608, 181663168, 181795136, +181926592, 182057536, 182190016, 182320192, 182451904, 182582336, +182713792, 182843072, 182976064, 183107264, 183237056, 183368384, +183494848, 183631424, 183762752, 183893824, 184024768, 184154816, +184286656, 184417984, 184548928, 184680128, 184810816, 184941248, +185072704, 185203904, 185335616, 185465408, 185596352, 185727296, +185859904, 185989696, 186121664, 186252992, 186383552, 186514112, +186645952, 186777152, 186907328, 187037504, 187170112, 187301824, +187429184, 187562048, 187693504, 187825472, 187957184, 188087104, +188218304, 188349376, 188481344, 188609728, 188743616, 188874304, +189005248, 189136448, 189265088, 189396544, 189528128, 189660992, +189791936, 189923264, 190054208, 190182848, 190315072, 190447424, +190577984, 190709312, 190840768, 190971328, 191102656, 191233472, +191364032, 191495872, 191626816, 191758016, 191888192, 192020288, +192148928, 192282176, 192413504, 192542528, 192674752, 192805952, +192937792, 193068608, 193198912, 193330496, 193462208, 193592384, +193723456, 193854272, 193985984, 194116672, 194247232, 194379712, +194508352, 194641856, 194772544, 194900672, 195035072, 195166016, +195296704, 195428032, 195558592, 195690304, 195818176, 195952576, +196083392, 196214336, 196345792, 196476736, 196607552, 196739008, +196869952, 197000768, 197130688, 197262784, 197394368, 197523904, +197656384, 197787584, 197916608, 198049472, 198180544, 198310208, +198442432, 198573632, 198705088, 198834368, 198967232, 199097792, +199228352, 199360192, 199491392, 199621696, 199751744, 199883968, +200014016, 200146624, 200276672, 200408128, 200540096, 200671168, +200801984, 200933312, 201062464, 201194944, 201326144, 201457472, +201588544, 201719744, 201850816, 201981632, 202111552, 202244032, +202374464, 202505152, 202636352, 202767808, 202898368, 203030336, +203159872, 203292608, 203423296, 203553472, 203685824, 203816896, +203947712, 204078272, 204208192, 204341056, 204472256, 204603328, +204733888, 204864448, 204996544, 205125568, 205258304, 205388864, +205517632, 205650112, 205782208, 205913536, 206044736, 206176192, +206307008, 206434496, 206569024, 206700224, 206831168, 206961856, +207093056, 207223616, 207355328, 207486784, 207616832, 207749056, +207879104, 208010048, 208141888, 208273216, 208404032, 208534336, +208666048, 208796864, 208927424, 209059264, 209189824, 209321792, +209451584, 209582656, 209715136, 209845568, 209976896, 210106432, +210239296, 210370112, 210501568, 210630976, 210763712, 210894272, +211024832, 211156672, 211287616, 211418176, 211549376, 211679296, +211812032, 211942592, 212074432, 212204864, 212334016, 212467648, +212597824, 212727616, 212860352, 212991424, 213120832, 213253952, +213385024, 213515584, 213645632, 213777728, 213909184, 214040128, +214170688, 214302656, 214433728, 214564544, 214695232, 214826048, +214956992, 215089088, 215219776, 215350592, 215482304, 215613248, +215743552, 215874752, 216005312, 216137024, 216267328, 216399296, +216530752, 216661696, 216790592, 216923968, 217054528, 217183168, +217316672, 217448128, 217579072, 217709504, 217838912, 217972672, +218102848, 218233024, 218364736, 218496832, 218627776, 218759104, +218888896, 219021248, 219151936, 219281728, 219413056, 219545024, +219675968, 219807296, 219938624, 220069312, 220200128, 220331456, +220461632, 220592704, 220725184, 220855744, 220987072, 221117888, +221249216, 221378368, 221510336, 221642048, 221772736, 221904832, +222031808, 222166976, 222297536, 222428992, 222559936, 222690368, +222820672, 222953152, 223083968, 223213376, 223345984, 223476928, +223608512, 223738688, 223869376, 224001472, 224132672, 224262848, +224394944, 224524864, 224657344, 224788288, 224919488, 225050432, +225181504, 225312704, 225443776, 225574592, 225704768, 225834176, +225966784, 226097216, 226229824, 226360384, 226491712, 226623424, +226754368, 226885312, 227015104, 227147456, 227278528, 227409472, +227539904, 227669696, 227802944, 227932352, 228065216, 228196288, +228326464, 228457792, 228588736, 228720064, 228850112, 228981056, +229113152, 229243328, 229375936, 229505344, 229636928, 229769152, +229894976, 230030272, 230162368, 230292416, 230424512, 230553152, +230684864, 230816704, 230948416, 231079616, 231210944, 231342016, +231472448, 231603776, 231733952, 231866176, 231996736, 232127296, +232259392, 232388672, 232521664, 232652608, 232782272, 232914496, +233043904, 233175616, 233306816, 233438528, 233569984, 233699776, +233830592, 233962688, 234092224, 234221888, 234353984, 234485312, +234618304, 234749888, 234880832, 235011776, 235142464, 235274048, +235403456, 235535936, 235667392, 235797568, 235928768, 236057152, +236190272, 236322752, 236453312, 236583616, 236715712, 236846528, +236976448, 237108544, 237239104, 237371072, 237501632, 237630784, +237764416, 237895232, 238026688, 238157632, 238286912, 238419392, +238548032, 238681024, 238812608, 238941632, 239075008, 239206336, +239335232, 239466944, 239599168, 239730496, 239861312, 239992384, +240122816, 240254656, 240385856, 240516928, 240647872, 240779072, +240909632, 241040704, 241171904, 241302848, 241433408, 241565248, +241696192, 241825984, 241958848, 242088256, 242220224, 242352064, +242481856, 242611648, 242744896, 242876224, 243005632, 243138496, +243268672, 243400384, 243531712, 243662656, 243793856, 243924544, +244054592, 244187072, 244316608, 244448704, 244580032, 244710976, +244841536, 244972864, 245104448, 245233984, 245365312, 245497792, +245628736, 245759936, 245889856, 246021056, 246152512, 246284224, +246415168, 246545344, 246675904, 246808384, 246939584, 247070144, +247199552, 247331648, 247463872, 247593536, 247726016, 247857088, +247987648, 248116928, 248249536, 248380736, 248512064, 248643008, +248773312, 248901056, 249036608, 249167552, 249298624, 249429184, +249560512, 249692096, 249822784, 249954112, 250085312, 250215488, +250345792, 250478528, 250608704, 250739264, 250870976, 251002816, +251133632, 251263552, 251395136, 251523904, 251657792, 251789248, +251919424, 252051392, 252182464, 252313408, 252444224, 252575552, +252706624, 252836032, 252968512, 253099712, 253227584, 253361728, +253493056, 253623488, 253754432, 253885504, 254017216, 254148032, +254279488, 254410432, 254541376, 254672576, 254803264, 254933824, +255065792, 255196736, 255326528, 255458752, 255589952, 255721408, +255851072, 255983296, 256114624, 256244416, 256374208, 256507712, +256636096, 256768832, 256900544, 257031616, 257162176, 257294272, +257424448, 257555776, 257686976, 257818432, 257949632, 258079552, +258211136, 258342464, 258473408, 258603712, 258734656, 258867008, +258996544, 259127744, 259260224, 259391296, 259522112, 259651904, +259784384, 259915328, 260045888, 260175424, 260308544, 260438336, +260570944, 260700992, 260832448, 260963776, 261092672, 261226304, +261356864, 261487936, 261619648, 261750592, 261879872, 262011968, +262143424, 262274752, 262404416, 262537024, 262667968, 262799296, +262928704, 263061184, 263191744, 263322944, 263454656, 263585216, +263716672, 263847872, 263978944, 264108608, 264241088, 264371648, +264501184, 264632768, 264764096, 264895936, 265024576, 265158464, +265287488, 265418432, 265550528, 265681216, 265813312, 265943488, +266075968, 266206144, 266337728, 266468032, 266600384, 266731072, +266862272, 266993344, 267124288, 267255616, 267386432, 267516992, +267648704, 267777728, 267910592, 268040512, 268172096, 268302784, +268435264, 268566208, 268696256, 268828096, 268959296, 269090368, +269221312, 269352256, 269482688, 269614784, 269745856, 269876416, +270007616, 270139328, 270270272, 270401216, 270531904, 270663616, +270791744, 270924736, 271056832, 271186112, 271317184, 271449536, +271580992, 271711936, 271843136, 271973056, 272105408, 272236352, +272367296, 272498368, 272629568, 272759488, 272891456, 273022784, +273153856, 273284672, 273415616, 273547072, 273677632, 273808448, +273937088, 274071488, 274200896, 274332992, 274463296, 274595392, +274726208, 274857536, 274988992, 275118656, 275250496, 275382208, +275513024, 275643968, 275775296, 275906368, 276037184, 276167872, +276297664, 276429376, 276560576, 276692672, 276822976, 276955072, +277085632, 277216832, 277347008, 277478848, 277609664, 277740992, +277868608, 278002624, 278134336, 278265536, 278395328, 278526784, +278657728, 278789824, 278921152, 279052096, 279182912, 279313088, +279443776, 279576256, 279706048, 279838528, 279969728, 280099648, +280230976, 280361408, 280493632, 280622528, 280755392, 280887104, +281018176, 281147968, 281278912, 281411392, 281542592, 281673152, +281803712, 281935552, 282066496, 282197312, 282329024, 282458816, +282590272, 282720832, 282853184, 282983744, 283115072, 283246144, +283377344, 283508416, 283639744, 283770304, 283901504, 284032576, +284163136, 284294848, 284426176, 284556992, 284687296, 284819264, +284950208, 285081536] +``` diff --git a/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md new file mode 100644 index 00000000000..8ccad3b6825 --- /dev/null +++ b/src/content/translations/zh/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md @@ -0,0 +1,37 @@ +--- +title: 挖矿算法 +description: 以太坊挖矿所用的算法的详细介绍 +lang: zh +--- + + +工作量证明不再是以太坊共识机制的基础，这意味着挖矿已终结。 取而代之的是，以太坊将由质押了以太币的验证者保护。 你可以立即开始质押以太币。 阅读更多关于合并、权益证明和质押的信息。 此页面仅为满足对历史的兴趣。 + + +以太坊挖矿使用过一种称为 Ethash 的算法。 该算法的基本思想是，矿工尝试使用蛮力计算找到一个随机数输入，使得生成的哈希小于一个取决于计算难度的阈值。 此难度级别可以动态调整，从而允许定期进行区块生产。 + +## 前提条件 {#prerequisites} + +为了更好地理解本页内容，推荐您先阅读[工作量证明共识](/developers/docs/consensus-mechanisms/pow)和[挖矿](/developers/docs/consensus-mechanisms/pow/mining)。 + +## Dagger Hashimoto {#dagger-hashimoto} + +Dagger Hashimoto 是以太坊挖矿的先导研究算法，现已被 Ethash 取代。 它是两种不同算法：Dagger 和 Hashimoto 的融合。 它只是一个研究实现，并在以太坊主网启动时被 Ethash 取代。 + +[Dagger](http://www.hashcash.org/papers/dagger.html) 会生成一个[有向无环图](https://en.wikipedia.org/wiki/Directed_acyclic_graph)，将共同取哈希值的内容随机划分。 其核心原理是，每个随机数只取总数据树的一小部分。 挖矿禁止为每个随机数重新计算子树，因此需要总存储树，但若为验证某个随机数的价值，则可以重新计算。 Dagger 的设计目的是替代诸如 Scrypt 的已有算法。后者是“内存困难算法”，但当它们的内存困难程度增加到可信的安全水平时将很难验证。 然而，Dagger 容易受到共享内存硬件加速的影响，因此我们放弃了这种算法，转而采用了其他研究途径。 + +[Hashimoto](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) 算法通过实现输入/输出密集的特性(即，内存读取速度是挖矿过程中的限制因素)来增加对专用集成电路的抵抗性。 理论上来说使用内存比使用计算能力更容易；已有价值数十亿美元的经费投入被用于研究针对不同应用场景的内存优化，通常涉及近随机访问模式(即“随机存取存储器”)。 因此，现有的内存对评价算法效率的能力更接近最优。 Hashimoto 使用区块链作为数据源，同时满足上述第 (1) 和第 (3) 条。 + +Dagger-Hashimoto 是在 Dagger 和 Hashimoto 的基础上改进而来的以太币挖矿算法。 Dagger Hashimoto 和 Hashimoto 的差别在于，Dagger Hashimoto 的数据来源并非是区块链，而是自定义生成的数据集，这些数据集将基于所有 N 区块上的区块数据进行更新。 这些数据集采用 Dagger 算法生成，可为轻量级客户端的验证算法高效计算特定于每个随机数的子集。 Dagger Hashimoto 算法和 Dagger 算法的差别在于，与原来的 Dagger 不同，用于查询区块的数据集只是暂时的，只会偶尔更新（例如每周更新一次）。 这意味着生成数据集的工作量接近于零，所以 Sergio Lerner 关于共享内存加速的论据变得微不足道。 + +详细了解 [Dagger-Hashimoto](/developers/docs/consensus-mechanisms/pow/mining-algorithms/dagger-hashimoto)。 + +## Ethash {#ethash} + +Ethash 是在现已弃用的工作量证明架构下，实际用于真正的以太坊主网的挖矿算法。 Ethash 实际上是为 Dagger Hashimoto 算法进行重要更新后的一个特殊版本命名的新名称，但它仍然继承了其前身的基本原理。 以太坊主网只使用过 Ethash - Dagger Hashimoto 是挖矿算法的研发版本，在以太坊主网上开始挖矿之前被取代。 + +[详细了解 Ethash](/developers/docs/consensus-mechanisms/pow/mining-algorithms/ethash)。 + +## 延伸阅读 {#further-reading} + +_还有哪些社区资源对您有所帮助？ 请编辑本页面并添加！_ diff --git a/src/content/translations/zh/developers/docs/data-and-analytics/block-explorers/index.md b/src/content/translations/zh/developers/docs/data-and-analytics/block-explorers/index.md index bb48b3d0374..e000ddac97d 100644 --- a/src/content/translations/zh/developers/docs/data-and-analytics/block-explorers/index.md +++ b/src/content/translations/zh/developers/docs/data-and-analytics/block-explorers/index.md @@ -21,6 +21,8 @@ sidebarDepth: 3 - [Ethplorer](https://ethplorer.io/) -_ 还支持中文、西班牙语、法语、土耳其语、俄语、韩语和越南语_ - [OKLink](https://www.oklink.com/eth) - [Otterscan](https://otterscan.io/) +- [Sirato](https://www.web3labs.com/sirato) +- [EthVM](https://www.ethvm.com/) ## 数据 {#data} diff --git a/src/content/translations/zh/developers/docs/data-and-analytics/index.md b/src/content/translations/zh/developers/docs/data-and-analytics/index.md index 15118059d18..75081d8cf53 100644 --- a/src/content/translations/zh/developers/docs/data-and-analytics/index.md +++ b/src/content/translations/zh/developers/docs/data-and-analytics/index.md @@ -30,7 +30,7 @@ lang: zh ## 客户端多样性 -[客户端多样性](/developers/docs/nodes-and-clients/client-diversity/)对于以太坊网络的整体健康很重要，因为它提供了对错误和漏洞利用的弹性。 现在有多个客户端多样性仪表板，包括 [clientdiversity.org](https://clientdiversity.org/)、[rated.network](rated.network)、[pool.invis.cloud](pool.invis.cloud)、[slashed.info](slashed.info) 和 [Ethernodes](https://ethernodes.org/)。 +[客户端多样性](/developers/docs/nodes-and-clients/client-diversity/)对于以太坊网络的整体健康很重要，因为它提供了对错误和漏洞利用的弹性。 目前，出现了一些客户端多样性仪表板，包括 [clientdiversity.org](https://clientdiversity.org/)、[rated.network](rated.network)、[execution-diversity.info](https://execution-diversity.info/) 和 [Ethernodes](https://ethernodes.org/)。 ## Dune Analytics {#dune-analytics} diff --git a/src/content/translations/zh/developers/docs/programming-languages/rust/index.md b/src/content/translations/zh/developers/docs/programming-languages/rust/index.md index 429795aad1d..4bfb9367370 100644 --- a/src/content/translations/zh/developers/docs/programming-languages/rust/index.md +++ b/src/content/translations/zh/developers/docs/programming-languages/rust/index.md @@ -30,32 +30,28 @@ incomplete: true ## 面向中等程度用户的文章 {#intermediate-articles} -- [Rust-Web3 相关文档](https://tomusdrw.github.io/rust-web3/web3/index.html) -- [Rust-Web3 工作示例](https://github.com/tomusdrw/rust-web3/blob/master/examples) - ## 面向高等程度用户的使用模式 {#advanced-use-patterns} - [pwasm_ethereum 外部库与类以太坊网络交互](https://github.com/openethereum/pwasm-ethereum) - [使用 JavaScript 和 Rust 搭建去中心化聊天室](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52) - [使用 Vue.js 和 Rust 构建一个去中心化待办事项应用程序](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb) -- [Secret 合约介绍](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) -- [用 Rust 构建区块链](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) +- [Secret Contracts 介绍](https://blog.enigma.co/getting-started-with-enigma-an-intro-to-secret-contracts-cdba4fe501c2) +- [使用 Rust 构建区块链](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/) ## Rust 项目和工具 {#rust-projects-and-tools} -- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _与类以太坊的网络交互的外部帐户集合_ +- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _与类似以太坊的网络交互的外部帐户集合_ - [Lighthouse](https://github.com/sigp/lighthouse) - _以太坊快速共识层客户端_ - [ Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _使用 WebAssembly 的确定性子集对以太坊智能合约执行层建议的重新设计_ -- [oasis_std](https://docs.rs/oasis-std/0.2.7/oasis_std/) - _OASIS 应用程序界面参考_ -- [Solaris](https://github.com/paritytech/sol-rs) - _使用本机 Parity 客户端以太坊虚拟机的 Solidity 智能合约单元测试框架。_ +- [oasis_std](https://docs.rs/oasis-std/0.2.7/oasis_std/) - _OASIS API 参考_ +- [Solaris](https://github.com/paritytech/sol-rs) - _使用本机 Parity 客户端以太坊虚拟机的 Solidity 智能合约单元测试工具。_ - [SputnikVM](https://github.com/rust-blockchain/evm) - _以太坊虚拟机的 Rust 实现_ -- [rust-web3](https://github.com/tomusdrw/rust-web3) - _ Web3.js 库 Rust 语言实现_ - [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Rust 语言的 Wavelet 智能合约_ -- [Foundry](https://github.com/gakonst/foundry) - _以太坊应用开发工具包_ -- [Ethers_rs](https://github.com/gakonst/ethers-rs)- _可实现以太坊库和钱包功能_ +- [Foundry](https://github.com/gakonst/foundry) - _以太坊应用程序开发工具包_ +- [Ethers_rs](https://github.com/gakonst/ethers-rs)- _以太坊库和钱包的实现_ - [SewUp](https://github.com/second-state/SewUp) - _一个帮助用户用 Rust 语言构建以太坊 Webassembly 合约的库，正如在公共后端中开发一样_ -- [Reth](https://github.com/paradigmxyz/reth) - Reth 即 Rust 以太坊的简称，是新的以太坊全节点实现。 +- [Reth](https://github.com/paradigmxyz/reth) - Reth 即 Rust 以太坊的简称及发音，是新的以太坊全节点实现 想要获取更多的资源？ 请浏览 [ethereum.org/developers](/developers/)。 diff --git a/src/content/translations/zh/developers/docs/scaling/index.md b/src/content/translations/zh/developers/docs/scaling/index.md index 953be3a5ae3..9c805557220 100644 --- a/src/content/translations/zh/developers/docs/scaling/index.md +++ b/src/content/translations/zh/developers/docs/scaling/index.md @@ -21,27 +21,25 @@ sidebarDepth: 3 ## 链上扩容 {#on-chain-scaling} -这种扩容方法需要变更以太坊协议（第一层[主网](/glossary/#mainnet)）。 区块分片目前是这种扩容方法的重点。 +链上扩容需要更改以太坊协议（一层网络[主网](/glossary/#mainnet)）。 长期以来，区块链分片有望扩展以太坊。 分片就是将区块链拆分成单独的部分（分片），并由部分验证者进行验证。 然而，二层网络卷叠扩容方案已取而代之，成为主要的扩容技术。 更加经济的向以太坊区块添加数据的新方式旨在让卷叠方案对用户经济划算，它的出现无疑为这一形势增添了助力。 ### 分片 {#sharding} -区块分片是一个横向分割数据库以扩展网络承载能力的过程。 在以太坊中，区块分片将通过创建新链（称为“分片”）来减少网络拥塞和增加每秒交易量。 这还可以减轻每位验证者的负担，因为他们不再需要处理整个网络的所有交易。 - -了解更多关于[区块分片](/roadmap/danksharding/)的信息。 +分片是拆分数据库的过程。 部分验证者将负责单独的分片，而不是跟踪整个以太坊。 分片包含在以太坊[路线图](/roadmap/)上由来已久，并且曾计划于合并到权益证明之前上线。 然而，[二层网络卷叠](#layer-2-scaling)的快速发展和 [Danksharding](/roadmap/danksharding) 的发明（将卷叠数据的二进制大对象添加以太坊区块中，并且验证者可以非常高效地进行验证），让以太坊社区青睐以卷叠为中心的扩容方案，而不是分片扩容方案。 这也将有助于保持以太坊的共识逻辑更简单。 ## 链下扩容 {#off-chain-scaling} -链下解决方案与第一层主网分开实施，无需更改现有以太坊协议。 部分解决方案称为“第二层”解决方案，直接从第一层以太坊共识中获得安全性，例如[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)、[零知识卷叠](/developers/docs/scaling/zk-rollups/)或[状态通道](/developers/docs/scaling/state-channels/)。 其他解决方案涉及创建独立于主网获取安全性的各种形式的新链，例如[侧链](#sidechains)、[Validium](#validium) 和 [Plasma](#plasma)。 这些解决方案与主网进行通信，但为了实现各种不同的目标，它们获得安全性的方式也有所不同。 +链下解决方案与一层网络主网分开实现，它们无需更改现有以太坊协议。 部分解决方案称为“二层网络”解决方案，它们直接从一层网络以太坊共识中获得安全性，例如[乐观卷叠](/developers/docs/scaling/optimistic-rollups/)、[零知识卷叠](/developers/docs/scaling/zk-rollups/)或[状态通道](/developers/docs/scaling/state-channels/)。 其他解决方案涉及创建独立于主网获取安全性的各种形式的新链，例如[侧链](#sidechains)、[Validium](#validium) 或 [Plasma 链](#plasma)。 这些解决方案与主网进行通信，但为了实现各种不同目标，它们获得安全性的方式也有所不同。 ### 二层扩容 {#layer-2-scaling} 此类链下解决方案的安全性来自以太坊主网。 -第二层是解决方案的一个集体术语，用于通过处理以太坊主网（第一层）的交易，同时利用主网的强大分散安全模式，帮助扩展您的应用程序。 当网络繁忙时，交易速度会受到影响，这可能使某些类型的去中心化应用程序的用户体验变差。 而且，随着网络越来越繁忙，由于交易发送者的目标是超越对方的出价，燃料价格也随之上升。 这可能会让以太坊的使用成本非常高。 +二层网络是一种统称，用来描述那些通过在以太坊主网（一层网络）下处理交易，同时利用主网强大的去中心化安全模型来帮助扩展你的应用程序的解决方案。 当网络繁忙时，交易速度会受到影响，这可能使某些类型的去中心化应用程序的用户体验变差。 而且，随着网络越来越繁忙，由于交易发送者的目标是超出对方的出价，燃料价格也随之上升。 这可能会让以太坊的使用成本非常高。 -大多数第二层解决方案均围绕着一个服务器或服务器群集，可以将它们称之为节点、验证者、运营商、排序者、区块生产者或类似术语。 根据实施情况，这些第二层节点可由使用它们的个人、企业或实体运行，或者由第三方运营商或一大群个人（与主网相似）运行。 一般而言，交易会提交给第二层节点，而非直接提交给第一层（主网）。 对于部分解决方案，二层网络实例会将它们分组，然后锚定到一层网络，之后受一层网络保护且不能更改。 对于不同的第二层技术和实施而言，如何做到这一点的细节差异很大。 +大多数二层网络解决方案均围绕着一个服务器或服务器群集，其中每一种都可以称为节点、验证者、运营商、排序者、区块生产者或类似术语。 根据实现情况，这些二层网络的节点可由使用它们的个人、企业或实体运行，或者由第三方运营商或一大群个人（与主网相似）运行。 一般而言，交易会提交给二层网络节点，而非直接提交给一层网络（主网）。 对于部分解决方案，二层网络实例会将它们分组,然后锚定到一层网络，之后它们受一层网络保护且不能更改。 对于不同的二层网络技术和实现而言，如何做到这一点，细节方面差异很大。 -某个特定的第二层实例可能是开放的，由许多应用程序共享，也可能由一个项目部署，专供支持该项目的应用程序。 +某个特定的二层网络实例可能是开放的，由许多应用程序共享，也可能由一个项目部署，专供支持该项目的应用程序。 #### 为什么需要第二层？ {#why-is-layer-2-needed} @@ -54,24 +52,24 @@ sidebarDepth: 3 #### 卷叠 {#rollups} -卷叠在一层网络之外执行交易，然后将数据发布到一层网络并在其中达成共识。 由于交易数据包含在一层网络区块中，因而可以通过原生的以太坊安全性来保证卷叠的安全性。 +卷叠在一层网络外执行交易，并在达成共识时，在一层网络公开数据。 由于交易数据包含在一层网络区块中，因此可以通过原生的以太坊安全性来保证卷叠的安全性。 -有两种使用了不同安全模式的卷叠： +有两种具有不同安全模型的卷叠： - **乐观卷叠**：假设交易在默认情况下有效，并且在遇到挑战的情况下只通过[**欺诈证明**](/glossary/#fraud-proof)运行计算。 [关于乐观卷叠的更多信息](/developers/docs/scaling/optimistic-rollups/)。 - **零知识卷叠**：在链下运行计算并向链上提交[**有效性证明**](/glossary/#validity-proof)。 [关于零知识卷叠的更多信息](/developers/docs/scaling/zk-rollups/)。 #### 状态通道 {#channels} -状态通道采用多重签名合约，使参与者能够在链下快速自由地进行交易，然后再与主网结算确定性。 这将最大限度减少网络拥塞、费用和延迟。 目前有两种通道：状态通道和支付通道。 +状态通道采用多签合约，使参与者能够在链下快速自由地进行交易，然后再与主网落实最终确定性。 这将最大限度地减少网络拥塞、费用和延迟。 现在有两种通道：状态通道和支付通道。 了解更多关于[状态通道](/developers/docs/scaling/state-channels/)的信息。 ### 侧链 {#sidechains} -侧链是与主网并行运行且兼容以太坊虚拟机的独立区块链。 它们通过双向桥接与以太坊兼容，并按照自行选择的共识规则和区块参数运行。 +侧链是与主网并行运行且兼容以太坊虚拟机的独立区块链。 它们通过双向桥接与以太坊兼容，按照自行选择的共识规则和区块参数运行。 -了解更多关于[侧链](/developers/docs/scaling/sidechains/)的信息。 +了解更多有关[侧链](/developers/docs/scaling/sidechains/)的信息。 ### 以太坊 Plasma 扩容解决方案 {#plasma} @@ -81,9 +79,9 @@ Plasma 是一条独立的区块链，锚定至以太坊主链，并使用欺诈 ### Validium {#validium} -Validium 链使用诸如零知识卷叠之类的有效性证明，但数据并未存储在一层以太坊链上。 这让每条 Validium 链每秒可以处理 10,000 笔交易，并且可以并行运行多条链。 +Validium 链使用诸如零知识卷叠之类的有效性证明，但数据未存储在一层网络以太坊主链上。 这会导致每条 Validium 链每秒处理 10000 笔交易，并且可以并行运行多条链。 -了解更多关于 [Validium](/developers/docs/scaling/validium/) 的信息。 +了解关于 [Validium](/developers/docs/scaling/validium/) 的更多信息。 ## 为何需要如此多扩容解决方案？ {#why-do-we-need-these} @@ -96,7 +94,7 @@ Validium 链使用诸如零知识卷叠之类的有效性证明，但数据并 -_请注意，视频中的说明使用“二层网络”术语指代所有链下扩容解决方案，而我们通常所说的“第二层”是指通过第一层主网共识获得安全性的链下解决方案。_ +_请注意，视频中的解释使用“二层网络”这一术语指代所有链下扩容解决方案，而我们通常所说的“二层网络”是指通过一层网络主网共识获得安全性的链下解决方案。_ @@ -112,4 +110,4 @@ _请注意，视频中的说明使用“二层网络”术语指代所有链下 - [为什么卷叠 + 数据分片是高可扩展性的唯一可持续的解决办法](https://polynya.medium.com/why-rollups-data-shards-are-the-only-sustainable-solution-for-high-scalability-c9aabd6fbb48) - [什么类型的三层网络有意义？](https://vitalik.ca/general/2022/09/17/layer_3.html) -_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_ +_还有哪些社区资源对您有所帮助？ 编辑并添加本页面！_ diff --git a/src/content/translations/zh/developers/docs/scaling/optimistic-rollups/index.md b/src/content/translations/zh/developers/docs/scaling/optimistic-rollups/index.md index 7c7e57a7935..a7c9001dd3a 100644 --- a/src/content/translations/zh/developers/docs/scaling/optimistic-rollups/index.md +++ b/src/content/translations/zh/developers/docs/scaling/optimistic-rollups/index.md @@ -198,7 +198,7 @@ ii. 使用乐观卷叠的开发者和项目团队可以利用以太坊的基础 2. **`calldata`**：除了基本交易费用之外，每个状态写入的成本取决于发布到 L1 的 `calldata` 大小。 `calldata` 费用目前由 [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) 监管，它规定对于 `calldata` 的非零字节和零字节费用分别为 16 单位和 4 单位燃料。 为了降低用户费用，卷叠运营商压缩交易以减少在以太坊上发布的 `calldata` 字节数。 -3. **L2 运营商费用**：这是支付给卷叠节点的金额，作为处理交易时产生的计算成本的补偿，就像以太坊上的矿工费一样。 卷叠节点收取的交易费用较低，因为 L2 具有更高的处理能力，并且不会面临网络拥塞，而网络拥塞会迫使以太坊上的矿工优先处理费用较高的交易。 +3. **二层网络运营商费用**：这是支付给卷叠节点的金额，用来补偿处理交易时产生的计算成本，很像以太坊上的燃料费用。 由于二层网络处理能力更强，并且不会出现网络拥塞迫使以太坊上的验证者优先处理费用更高的交易，卷叠节点收取的交易费更低。 乐观卷叠应用了多种机制来降低用户的费用，包括批量交易和压缩 `calldata` 以降低数据发布成本。 你可以查看 [L2 费用跟踪器](https://l2fees.info/)，实时了解使用基于以太坊的乐观卷叠的成本。 @@ -229,7 +229,7 @@ ii. 使用乐观卷叠的开发者和项目团队可以利用以太坊的基础 这是一个比较乐观的估计，因为乐观卷叠交易不可能包含以太坊上的整个区块。 但是，它可以大致了解乐观卷叠可以为以太坊用户提供多少可扩展性收益（当前实现可提供高达 2,000 交易每秒的速率）。 -在以太坊上引入[数据分片](/roadmap/danksharding/)有望提高乐观卷叠的可扩展性。 由于卷叠交易必须与其他非卷叠交易共享区块空间，因此它们的处理能力受到以太坊主链上的数据吞吐量的限制。 分片将增加可供 L2 链发布每个区块的数据的空间，进一步提高卷叠的吞吐量。 +在以太坊上引入[数据分片](/roadmap/danksharding/)有望提高乐观卷叠的可扩展性。 由于卷叠交易必须与其他非卷叠交易共享区块空间，因此它们的处理能力受到以太坊主链上的数据吞吐量的限制。 Danksharding 使用更经济的非永久型“二进制大对象”存储，而弃用昂贵的永久型 `CALLDATA`，这将增加二层网络链上用于发布每个区块中数据的空间。 ### 乐观卷叠的优缺点 {#optimistic-rollups-pros-and-cons} diff --git a/src/content/translations/zh/developers/docs/scaling/plasma/index.md b/src/content/translations/zh/developers/docs/scaling/plasma/index.md index 5541d88590d..89af4bae30a 100644 --- a/src/content/translations/zh/developers/docs/scaling/plasma/index.md +++ b/src/content/translations/zh/developers/docs/scaling/plasma/index.md @@ -150,12 +150,14 @@ Plasma、侧链、分片技术有一定的相似度，因为它们都以某种 ### Plasma 与分片 {#plasma-vs-sharding} -Plasma 链和[分片链](/roadmap/danksharding/)都会定期向以太坊主网发布加密证明。 但是，两者具有不同的安全属性。 +Plasma 链和分片链都定期向以太坊主网发布加密证明。 但是，两者具有不同的安全属性。 分片链向主网提交“汇总头”，其中包含有关每个数据分片的详细信息。 主网上的节点验证和执行数据分片的有效性，减少无效分片转换的可能性并防止网络上出现恶意活动。 Plasma 不同于此，因为主网只接收最少量的子链状态信息。 这意味着主网无法有效验证子链上进行的交易，降低了交易的安全性。 +**注意**：以太坊区块链分片已经不再包含在路线图中。 它已被卷叠及 [Danksharding](/roadmap/danksharding) 扩容方案所取代。 + ### 使用 Plasma {#use-plasma} 许多项目提供 Plasma 实现，你可以将它们集成到自己的去中心化应用程序中： @@ -173,4 +175,4 @@ Plasma 不同于此，因为主网只接收最少量的子链状态信息。 这 - [了解 Plasma（第一部分）：基础知识](https://www.theblockcrypto.com/amp/post/10793/understanding-plasma-part-1-the-basics) - [Plasma 的一生](https://medium.com/dragonfly-research/the-life-and-death-of-plasma-b72c6a59c5ad#) -_还有哪些社区资源对你有所帮助？ 请编辑本页面并添加！_ +_还有哪些社区资源对您有所帮助？ 编辑并添加本页面！_ diff --git a/src/content/translations/zh/developers/docs/scaling/sidechains/index.md b/src/content/translations/zh/developers/docs/scaling/sidechains/index.md index 350567bd72d..2080f9c64e4 100644 --- a/src/content/translations/zh/developers/docs/scaling/sidechains/index.md +++ b/src/content/translations/zh/developers/docs/scaling/sidechains/index.md @@ -18,7 +18,7 @@ sidebarDepth: 3 使侧链独一无二（即不同于以太坊）的特点之一是使用了共识算法。 侧链不依赖以太坊达成共识，并可以选择适合其需求的替代共识协议。 侧链上使用的共识算法的一些示例包括： - [权威证明](https://wikipedia.org/wiki/Proof_of_authority) -- [委托权益证明](https://en.bitcoinwiki.org/wiki/DPoS) +- [委托权益证明](https://en.bitcoin.it/wiki/Delegated_proof_of_stake) - [拜占庭容错算法](https://decrypt.co/resources/byzantine-fault-tolerance-what-is-it-explained)。 与以太坊一样，侧链也有验证并处理交易、生成区块以及存储区块链状态的验证节点。 验证者还负责维护整个网络的共识，并保护网络免受恶意攻击。 diff --git a/src/content/translations/zh/developers/docs/scaling/validium/index.md b/src/content/translations/zh/developers/docs/scaling/validium/index.md index c8330fad09d..e4b8371c7db 100644 --- a/src/content/translations/zh/developers/docs/scaling/validium/index.md +++ b/src/content/translations/zh/developers/docs/scaling/validium/index.md @@ -121,7 +121,7 @@ Volitions 结合了零知识卷叠和 Validium 链，它允许用户在两种扩 ### 1. 链下数据存储 {#off-chain-data-storage} -二层网络扩容项目（例如乐观卷叠和零知识卷叠）通过将部分交易数据发布到一层网络，牺牲了纯链下扩容协议（例如 [Plasma](/developers/docs/scaling/plasma/)）的无限可扩展性来换取安全性。 然而，这意味着卷叠的可扩展性属性受到以太坊主网上的数据带宽的限制（为此，[数据分片](/roadmap/danksharding/)提议是要提高以太坊的数据存储容量）。 +二层网络扩容项目（例如乐观卷叠和零知识卷叠）通过将部分交易数据发布到一层网络，牺牲了纯链下扩容协议（例如 [Plasma](/developers/docs/scaling/plasma/)）的无限可扩展性来换取安全性。 然而，这意味着卷叠的可扩展性属性受到以太坊主网上数据带宽的限制（因此，[数据分片](/roadmap/danksharding/)提议要提高以太坊的数据存储容量）。 Validium 实现了可扩展性，它将所有交易数据保存在链下并且在将状态更新传送到以太坊主链时仅发布状态承诺（和有效性证明）。 然而，有效性证明的存在为 Validium 提供了比其他纯链下扩容解决方案（包括 Plasma 和[侧链](/developers/docs/scaling/sidechains/)）更高的安全保障。 通过减少以太坊在验证链下交易之前必须处理的数据量，Validium 设计极大地提升了主网上的吞吐量。 diff --git a/src/content/translations/zh/developers/docs/scaling/zk-rollups/index.md b/src/content/translations/zh/developers/docs/scaling/zk-rollups/index.md index 750a3876779..097a08d6236 100644 --- a/src/content/translations/zh/developers/docs/scaling/zk-rollups/index.md +++ b/src/content/translations/zh/developers/docs/scaling/zk-rollups/index.md @@ -232,13 +232,15 @@ ZK-STARK 对于量子计算机也是安全的，而 ZK-SNARK 中使用的椭圆 零知识以太坊虚拟机上运行的项目包括： -- **[ZKSync](https://docs.zksync.io/zkevm/)** - _ZkSync 2.0 是由 Matter Labs 构建的与以太坊虚拟机兼容的零知识卷叠，由其自己的零知识以太坊虚拟机提供支持。_ - - **[Applied ZKP](https://github.com/privacy-scaling-explorations/zkevm-specs)** - _Applied ZKP 是由以太坊基金会资助的项目，旨在开发与以太坊虚拟机兼容的零知识卷叠以及为以太坊区块生成有效性证明的机制。_ +- **[Polygon zkEVM](https://polygon.technology/solutions/polygon-zkevm)** - _是以太坊主网上的去中心化零知识卷叠，它在零知识以太坊虚拟机 (zkEVM) 上运行，以透明的方式执行以太坊交易，包括智能合约与零知识证明验证。_ + - **[Scroll](https://scroll.io/blog/zkEVM)** - _Scroll 是 一家致力于为以太坊构建原生零知识以太坊虚拟机二层解决方案的技术驱动型公司。_ -- **[Polygon zkEVM](https://polygon.technology/solutions/polygon-zkevm)** - _是以太坊主网上的去中心化零知识卷叠，它在零知识以太坊虚拟机 (zkEVM) 上运行，以透明的方式执行以太坊交易，包括智能合约与零知识证明验证。_ +- **[Taiko](https://taiko.xyz)** - _Taiko 是去中心化的、等同于以太坊的零知识卷叠（[1 类零知识以太坊虚拟机](https://vitalik.ca/general/2022/08/04/zkevm.html)）。_ + +- **[ZKSync](https://docs.zksync.io/zkevm/)** - _ZkSync 2.0 是与以太坊虚拟机兼容的零知识卷叠，由 Matter Labs 构建并由它自己的零知识以太坊虚拟机提供支持。_ ## 进一步阅读零知识卷叠的相关内容 {#further-reading-on-zk-rollups} diff --git a/src/content/translations/zh/nft/index.md b/src/content/translations/zh/nft/index.md index 347c9f9eb0e..d9d86a8a9bf 100644 --- a/src/content/translations/zh/nft/index.md +++ b/src/content/translations/zh/nft/index.md @@ -351,5 +351,6 @@ Decentraland 是一款虚拟现实游戏，甚至允许玩家购买代表虚拟 - [您需要了解的元宇宙](https://foundation.app/blog/enter-the-metaverse) - _Foundation 团队，foundation.app_ - [CryptoArtists 没有危害地球](https://medium.com/superrare/no-cryptoartists-arent-harming-the-planet-43182f72fc61) - [以太坊的能源消耗](/energy-consumption/) +- [以太坊非同质化代币应用程序接口](https://www.alchemy.com/list-of/nft-apis-on-ethereum) - _Alchemy_ diff --git a/src/content/translations/zh/staking/pools/index.md b/src/content/translations/zh/staking/pools/index.md index 2035271e76d..558b663f34f 100644 --- a/src/content/translations/zh/staking/pools/index.md +++ b/src/content/translations/zh/staking/pools/index.md @@ -64,11 +64,7 @@ summaryPoints: -目前，无法从以太坊验证者中提取资金，这限制了实际中用流动性代币兑换锁定在共识层中以太币奖励的能力。 - -上海网络升级将引入提款功能，计划于 2023 年 4 月 12 日推出。 在此之前，所有质押的以太币都一直被锁定。 - -上海升级后，支持质押池的验证者帐户将能够退出并将以太币提取到指定的提取地址。 这样，你便能够用自己的一部分质押兑换底层以太币。 请咨询你的提供商，了解他们如何支持此功能。 +现在！马上！ 上海/卡佩拉网络升级发生在 2023 年 4 月，并引入了质押提款。 支持质押池的验证者帐户现在能够退出并将以太币提取到他们指定的提款地址。 这样你便能够赎回自己那部分质押的底层以太币。 请咨询你的提供商，了解他们如何支持此功能。 或者，使用 ERC-20 流动性代币的资金池允许用户在公开市场上交易该代币，允许你出售你的质押店铺位置，有效地“取款”，而无需实际从质押合约中移除以太币。 diff --git a/src/content/translations/zh/staking/saas/index.md b/src/content/translations/zh/staking/saas/index.md index 30ef2ebaf9c..4581ccd3f54 100644 --- a/src/content/translations/zh/staking/saas/index.md +++ b/src/content/translations/zh/staking/saas/index.md @@ -58,7 +58,7 @@ summaryPoints: ## 常见问题 {#faq} - 不同的提供商会有不同的安排，但通常情况下，他们都会指导你设置所需的签名密钥（每 32 个以太币需要一个签名密钥），并将这些密钥上传给你的服务提供商，让他们代表你进行验证。 这些签名密钥本身并没有提现、转帐或者花费你资金的权限。 他们只提供为达成共识而投票的权限，如果投票执行方式不恰当，可能会受到离线处罚或罚没。 +不同的提供商会有不同的安排，但通常情况下，他们都会指导你设置所需的签名密钥（每 32 个以太币需要一个签名密钥），并将这些密钥上传给你的服务提供商，让他们代表你进行验证。 这些签名密钥本身并没有提现、转帐或者花费你资金的权限。 他们只提供为达成共识而投票的权限，如果投票执行方式不恰当，可能会受到离线处罚或罚没。 @@ -66,25 +66,25 @@ summaryPoints: BLS 提款密钥用于签署一次性信息，声明质押奖励和退出的资金应该转入哪个执行层帐户。 在该信息广播后，不再需要 BLS 提款密钥。 然而，已提取资金的控制权将永久委托给你提供的地址。 因此，你可以设置一个用自己的冷存储保护的提款地址，即使有人控制了你的验证者签名密钥，也可以最大程度降低验证者资金的风险。 -上海升级后，更新提款凭据是进行提款的必需步骤。 此过程包括使用自己的助记词生成提款密钥。 确保安全备份了该助记词，否则在需要时你将无法生成提款密钥。 +更新提款凭证是进行提款的必需步骤\*。 此过程包括使用自己的助记词生成提款密钥。 -提供了提款地址和初始存款的质押人不需要设置此项。 如需有关准备验证者方面的支持，请联系你的质押即服务提供商。 +确保安全备份该助记词，否则在需要时将无法生成提款密钥。 + +\*提供了提款地址和初始存款的质押人不需要设置此项。 如需有关准备验证者方面的支持，请联系你的质押即服务提供商。 -将 32 个以太币质押给质押即服务提供商时，你的以太币依然存入官方质押存款合约中。 因此，质押即服务质押人受到与单独质押人相同的提款限制，而且在上海升级之前不支持提款。 - -质押提款将在即将进行的上海升级中实现，上海升级预计将于 2023 年 4 月 12 日实施。 之后，质押人需要提供一个提款地址（如果在初始存款时没有提供），将开始每隔几天定期自动分发奖励付款。 +2023 年 4 月，上海/卡佩拉升级实现了质押提款功能。 质押人需要提供一个提款地址（如果在初始存款时没有提供），并将开始每隔几天定期自动分发奖励支付。 -这也会让退出的资金解锁。 验证者能够以验证者身份完全退出，他们将在提供的提款地址中收到全部余额。 +验证者还能够以验证者身份完全退出，这种情况下，他们剩余的以太币余额将解锁以供提取。 提供执行提款地址并完成退出流程的帐户将在下次验证者扫描时在提供的提款地址收到其全部余额。 更多关于质押提款的信息 -使用质押即服务提供商，你需要将节点运营委托给别人。 这伴随着一些你不能控制的节点性能不佳的风险。 如果你的验证者受到罚没，你的验证者余额将因处罚而遭受损失，验证者也将从验证者池中强行移除。 这些资金将被锁定，直到协议层的提款功能得到实现。 +使用质押即服务提供商，你需要将节点运营委托给别人。 这伴随着一些你不能控制的节点性能不佳的风险。 如果你的验证者受到罚没，你的验证者余额将因处罚而遭受损失，验证者也将从验证者池中强行移除。 -即将到来的上海升级带来了提款功能，需要提供提款地址才能启用该功能。 提款地址可能已在初次存款时提供。 如果未提供，那么在升级上线后，就需要使用验证者签名密钥对声明提款地址的信息进行签名。 +在罚没/退出流程结束后，这些资金将转移到分配给验证者的提款地址。 需要提供一个提款地址才能实现资金转移。 提款地址可能已在初次存款时提供。 如果没有提供，就需要使用验证者提款密钥签署一条声明提款地址的信息。 如果没有提供提款地址，资金将保持锁定状态，直到提供提款地址为止。 有关任何担保或保险方案的详细信息，以及如何提供提款地址的说明，请联系各质押即服务提供商。 如果你想完全控制你的验证者设置，请详细了解如何单独质押以太币。 diff --git a/src/content/translations/zh/staking/solo/index.md b/src/content/translations/zh/staking/solo/index.md index 6a796ce3ca9..a4d32a014c4 100644 --- a/src/content/translations/zh/staking/solo/index.md +++ b/src/content/translations/zh/staking/solo/index.md @@ -40,32 +40,37 @@ summaryPoints: 尽管我们希望每个人都能无风险地进行单独质押，但这并不现实。 在选择单独质押以太币之前，有一些实际和严肃的事项需要记住。 - - 在操作自己的节点时，你应该花一些时间学习如何使用你所选择的软件。 这涉及到阅读相关文档，以及了解开发团队的沟通渠道。 - 你对所运行的软件和权益证明的原理了解得越多，作为一名质押人的风险就越小，也越容易解决在节点运行过程中可能出现的任何问题。 - - - 节点设置要求用户能够熟练使用计算机，尽管随着时间的推移，新的工具正在使其变得更容易。 了解命令行界面会有帮助，但并非必需。 - 节点设置还需要用户对基本的硬件设置，以及最低推荐规格有一些了解。 - - - 就像私钥保护了你的以太坊钱包一样，你也需要为验证者单独生成密钥。 你必须了解如何保障助记词或私钥的安全。 -

以太坊安全和预防欺诈措施

- - - 目前还不支持从验证者余额中提取质押的以太币或奖励。 计划为即将到来的上海升级提供提款支持。 此后，用户可以选择自动接收奖励付款，并且可以提取全部余额以收回他们的资金。 - - - 硬件设施会发生故障，网络连接会出错，客户端软件也需要升级。 因此节点维护不可避免，需要你偶尔关注。 你要确保知道任何预期的网络升级，或其他关键的客户端升级。 - - - 你的回报与你的验证者在线并正确验证的时间成正比。 宕机会导致一定比例的处罚，具体与有多少其他验证者同时离线有关，但不会导致罚没。 同时网络带宽也很重要，因为如果没有及时收到认证，奖励就会减少。 建议至少要有 10 Mb/s 的上行和下行带宽。 - - - 与离线导致的怠工处罚不同，罚没是一种更严重的处罚，专门针对恶意违规。 同一时间只在一台机器上运行加载你密钥的客户端，你被罚没的风险可以降到最低。 总得来说，所有质押人都必须意识到被罚没的风险。 - -

更多关于罚没和验证者周期的信息

- + +在操作自己的节点时，你应该花一些时间学习如何使用你所选择的软件。 这涉及到阅读相关文档，以及了解开发团队的沟通渠道。 + +你对所运行的软件和权益证明的原理了解得越多，作为一名质押人的风险就越小，也越容易解决在节点运行过程中可能出现的任何问题。 + + + +节点设置要求用户能够熟练使用计算机，尽管随着时间的推移，新的工具正在使其变得更容易。 了解命令行界面会有帮助，但并非必需。 + +节点设置还需要用户对基本的硬件设置，以及最低推荐规格有一些了解。 + + + +就像私钥保护以太坊地址的方式一样，你也需要为验证者单独生成密钥。 你必须了解如何确保助记词或私钥安全无虞。 + +以太坊安全和预防诈骗 + + + +硬件设施会发生故障，网络连接会出错，客户端软件也需要升级。 因此节点维护不可避免，需要你偶尔关注。 你要确保知道任何预期的网络升级，或其他关键的客户端升级。 + + + +你的回报与你的验证者在线并正确验证的时间成正比。 宕机会导致一定比例的处罚，具体与有多少其他验证者同时离线有关，但不会导致罚没。 同时网络带宽也很重要，因为如果没有及时收到认证，奖励就会减少。 建议至少要有 10 Mb/s 的上行和下行带宽。 + + + +与离线导致的怠工处罚不同，罚没是一种更严重的处罚，专门针对恶意违规。 同一时间只在一台机器上运行加载你密钥的客户端，你被罚没的风险可以降到最低。 总得来说，所有质押人都必须意识到被罚没的风险。 + +更多关于罚没和验证者生命周期的信息 + @@ -78,8 +83,6 @@ summaryPoints: 如果需要，你可以验证者身份退出，这样就不需要在线，也不会再有任何奖励。 之后，你的余额将提取到你在设置过程指定的提款地址。 -_上海升级后，才支持已退出验证者的奖励支付和全额提款。_ - [更多关于质押提款的信息](/staking/withdrawals/) ## 开始使用 Staking Launchpad {#get-started-on-the-staking-launchpad} @@ -126,14 +129,14 @@ Staking Launchpad 是一个开源应用程序，可帮助你成为质押人。 -验证者是一个存在于以太坊上并参与以太坊协议共识的虚拟实体。 验证者由余额、公钥和其他属性信息表示。 验证者客户端是代表验证者通过持有和使用其私钥进行操作的软件。 一个验证者客户端可以持有多个密钥对，从而控制多个验证者。 +验证者是一个虚拟实体，存在于以太坊上并参与以太坊协议的共识。 验证者由余额、公钥和其他属性信息表示。 验证者客户端是通过持有并使用验证者的私钥代表验证者行动的软件。 一个验证者客户端可以持有多个密钥对，从而控制多个验证者。 每个与验证者相关的密钥对都需要正好 32 个以太币才能激活。 将更多以太币存入一对密钥并不能增加可能获得的奖励，因为每个验证者的有效余额被限制为 32 个以太币。 这意味着质押时需要以 32 个以太币为单位递增，每个验证者都有自己的一套密钥和余额。 -不要为一个验证者存入超过 32 以太币的资金。 这不会增加你的奖励，而且资金会被锁定，直到计划执行的上海更新完成为止。 +不要为一个验证者存入超过 32 以太币的资金。 这样做不会增加你的奖励。 如果为验证者设置了提款地址，超过 32 个以太币多余资金将在下一次验证者扫描时自动提取到该地址。 如果单独质押对你来说要求太高，可以考虑使用质押即服务提供商，或者如果你的资金少于 32 个以太币，则可以考虑联合质押。 @@ -155,8 +158,10 @@ Staking Launchpad 是一个开源应用程序，可帮助你成为质押人。 非主流客户端中的等效错误永远不会被最终确认，因此也不会导致环绕投票，只会导致怠工处罚，而非罚没。 -

详细了解运行非主流客户端的重要性。

-

了解更多关于预防罚没的信息

+ @@ -176,9 +181,9 @@ Staking Launchpad 是一个开源应用程序，可帮助你成为质押人。 -实施上海升级时，将开始支持已退出验证者的奖励支付和全额提款。 从信标链上进行任何类型的提款都需要设置提款凭据。 +从信标链上进行任何类型的提款都需要设置提款凭据。 -新质押人在生成密钥和存款时设置提款凭据。 尚未设置提款凭据的现有质押人可以升级他们的密钥，以便在上海升级后支持提款功能。 +新质押人在生成密钥和存款时设置提款凭据。 尚未设置提款凭证的现有质押人可以升级他们的密钥，以支持提款功能。 设置提款凭据后，奖励支付（最初的 32 个以太币累积的以太币奖励）将自动定期分发到提款地址。 diff --git a/src/content/translations/zh/staking/withdrawals/index.md b/src/content/translations/zh/staking/withdrawals/index.md index 25836a7ecc6..a460835f53b 100644 --- a/src/content/translations/zh/staking/withdrawals/index.md +++ b/src/content/translations/zh/staking/withdrawals/index.md @@ -7,17 +7,19 @@ image: ../../../../../assets/staking/leslie-withdrawal.png alt: 犀牛莱斯利与她的质押奖励 sidebarDepth: 2 summaryPoints: - - 上海升级在以太坊上启用质押提款 + - 上海/卡佩拉升级实现了以太坊上的质押提款功能。 - 验证者操作员必须提供一个提款地址以启用 - 奖励每隔几天自动分发 - 完全退出质押的验证者将收到他们的剩余余额 --- - 质押提款将通过上海/卡佩拉升级启用。 这次以太坊网络升级预计将在 2023 年上半年进行。 更多内容如下 +2023 年 4 月 12 日进行的上海/卡佩拉升级已实现质押提款功能。 更多关于上海/卡佩拉升级的信息 -上海/卡佩拉升级在以太坊上启用**质押提款**，允许人们解锁以太币质押奖励。 奖励支付将自动定期发送到与各个验证者关联的提款地址。 用户还可以完全退出质押，解锁他们全部的验证者余额。 +**质押提款**是指将以太币从以太坊共识层（信标链）上的验证者帐户转移到可以进行交易的执行层。 + +用户提供提款地址后，超过 32 个以太币的余额的**奖励支付**将自动定期发送到和每个验证者相关的提款地址。 用户还可以**完全退出质押**，解锁他们全部的验证者余额。 ## 质押奖励 {#staking-rewards} @@ -29,9 +31,9 @@ summaryPoints: 在过去的几年里，以太坊经历了几次网络升级，从依赖能源密集型挖矿的网络转变为由以太坊本身保护的网络。 现在，在以太坊上参与共识被称为“质押”，因为参与者自愿锁定以太币，将其“押注”以参与网络。 遵守规则的用户将获得奖励，而尝试欺骗的行为可能会受到惩罚。 -自 2020 年 11 月质押存款合约启动以来，一些勇敢的以太坊先驱者自愿锁定资金以激活“验证者”，这些账户有权按照网络规则正式证明和提议区块。 +自 2020 年 11 月推出质押存款合约以来，一些勇敢的以太坊先驱者自愿锁定资金以激活“验证者”，验证者即遵循网络规则有权正式证明和提出区块的特殊帐户。 -在上海升级之前，您无法使用或访问您质押的以太币。 但现在，您可以选择自动将奖励发送到提供的帐户，并且还可以随时提取您抵押的以太币。 +在上海/卡佩拉升级之前，你可能无法使用或访问自己质押的以太币。 但现在，你可以选择在选定的帐户自动接收你的奖励，也可以随时提取质押的以太币。 ### 我应该如何准备？ {#how-do-i-prepare} @@ -45,7 +47,7 @@ summaryPoints: 每个验证者帐号只能分配一个提款地址，且仅限一次。一旦选择一个地址并将其提交到信标链，这个地址不能撤消或再次更改。 在提交前，请仔细检查所提供地址的所有权和准确性。 -同时，您的资金不会因不提供提款地址而受到威胁。 未添加提款凭据只会将以太币保持锁定在验证者帐户中，直到提供提款地址为止。 +同时，如果你的助记符/助记词在离线时一直保持安全，没有受到任何损害。不提供提款地址不会给你的资金带来任何威胁。 未添加提款凭据只会将以太币保持锁定在验证者帐户中，直到提供提款地址为止。 ## 完全退出质押 {#exiting-staking-entirely} @@ -53,15 +55,18 @@ summaryPoints: 希望完全退出质押并取回全部余额的用户还必须使用验证者密钥签署并广播一个“自愿退出”的消息，这将启动退出质押的过程。 这是通过您的验证者客户端完成的，并提交给您的信标节点，无需燃料。 -验证者从抵押退出的过程所需时间不同，具体取决于同时退出的人数。 一旦完成，此帐户将不再负责执行验证者网络职责，不再有资格获得奖励，并且不再拥有“质押”的以太币。 此时，帐户将被标记为完全“可提款”。 +验证者从抵押退出的过程所需时间不同，具体取决于同时退出的人数。 一旦完成，此帐户将不再负责执行验证者网络职责，不再有资格获得奖励，并且不再拥有“质押”的以太币。 此时，该帐户将被标记为完全“可提款”。 一旦帐户被标记为“可提款”，并且已提供提款凭据，用户除了等待之外，无需再做任何事情。 区块提议者会自动且持续地扫描是否有可退出资金，并在下一次扫描期间将您帐户的余额全额转移（也称为“全额提款”）。 ## 何时启用质押提款？ {#when} -提款功能将通过两部分同时进行的网络升级启用，即**上海 + 卡佩拉**。 +质押提款已经上线！ 提款功能已在 2023 年 4 月 12 日进行的上海/卡佩拉升级中实现。 + +上海/卡佩拉升级后，可以将之前质押的以太币收回到普通以太坊帐户中。 这就结束了质押流动性循环，并使以太坊向着建立一个可持续、可扩展、安全的去中心化生态系统迈进一步。 - +- [更多关于以太坊历史的信息](/history/) +- [更多关于以太坊路线图的信息](/roadmap/) ## 提款支付是如何运作的？ {#how-do-withdrawals-work} @@ -98,7 +103,7 @@ summaryPoints: ### 免燃料费 {#gas-free} -这种质押提款方法不需要质押人手动提交交易来请求提款特定数量以太币。 这也意味着**不需要支付燃料（交易费用）**，并且提款也不会争夺现有执行层区块空间。 +这种质押提款方法不需要质押人手动提交交易来请求提款特定数量以太币。 这意味着**不需要提交燃料费（交易费）**，并且提款也不争夺现有的执行层区块空间。 ### 我会多久收到一次质押奖励？ {#how-soon} @@ -118,7 +123,7 @@ summaryPoints: -正如您所看到的，随着网络上的验证者数量增加，完成该过程的速度也会变慢。 增加错过区块可能会成比例地减缓该过程，但这通常代表了可能结果中较慢的一面。 +正如您所看到的，随着网络上的验证者数量增加，完成该过程的速度也会变慢。 错过的时隙数增加可能成比例减慢提款速度，但这通常代表了可能的结果中较慢的情况。 ## 常见问题 {#faq} @@ -148,9 +153,10 @@ eventCategory="FAQ" eventAction="What if I participate in liquid staking derivatives or pooled staking" eventName="read more"> -

如果你是质押池的一部分或持有流动性质押衍生品，则应向你的提供商详细咨询质押提款将如何影响您的安排，因为每个服务运作方式不同。

-

一般来说，用户可能不需要做任何事情，在升级后，这些服务将不再受到无法提取奖励或退出验证者资金的限制。

-

这意味着用户现在可以决定赎回其正在被质押的以太币，或更改他们使用的质押服务提供商。 如果特定的质押池变得过于庞大，资金可以退出并赎回，并重新使用规模较小的提供商进行质押。 或者，如果你已经积累了足够的以太币，你可以自行质押。

+如果你参加了质押池，或持有流动性质押衍生品，你应该咨询你的提供商查，了解更多关于如何处理质押提款的细节，因为每种服务的运作方式不同。 + +一般来说，用户应该可以随意收回他们的底层质押以太币，或者更换他们使用的质押服务提供商。 如果某个质押池变得过大，可以退出、收回资金，并通过较小的提供商重新质押。 或者，如果你已经积攒了足够多的以太币，你就可以自行质押。 + - -

是的，只要你的验证者提供了提款地址。 必须提供一次才能启用任何提款，然后每隔几天，每次验证者扫描都会自动触发奖励支付。

+是的，只要你的验证者提供了提款地址。 提款地址必须要提供一次，以便在最初时启用任何提款，之后奖励支付将每隔几天在进行验证者扫描时自动分发。 -

不。如果您的验证者仍在网络上运行，则不会自动执行完全提款。 需要手动发起自愿退出。

-

一旦验证者完成退出过程，并且假设该账户具有提款凭证，则剩余余额将在下一个验证者扫描期间进行提款。

+不。如果您的验证者仍在网络上运行，则不会自动执行完全提款。 需要手动发起自愿退出。 + +一旦验证者完成退出流程，并且假设该帐户具有提款凭证，则剩余余额随后将在下一次验证者扫描期间提取。 + +提款旨在自动推送，转移任何未积极为质押做贡献的以太币。 这包括已完成退出流程的帐户的全部余额。 -

提款旨在自动推送，转移任何未积极为质押做贡献的以太币。 这包括帐号的全部余额。

-

无法手动请求要提取以太币的具体数量。

+无法手动请求要提取以太币的具体数量。 -

建议验证者操作者访问质押启动板提款页面，详细了解如何做好准备、事件的时间安排以及提款如何运作。

+建议验证者操作员访问质押启动板提款页面，了解有关如何准备验证者以进行提款的更多详细信息。 做好准备、安排好事件进行时间，了解有关提款功能的更多详细信息。 + +要首先在测试网上测试你的设置，请访问 Goerli 测试网质押启动板开始测试。 + - -

否。 一旦验证者退出并提取其全部余额，存入该验证者的任何额外资金将在下一次验证者扫描期间自动转移到提款地址。 要重新质押以太币，必须激活新的验证者。

+否。 一旦验证者退出并提取其全部余额，存入该验证者的任何额外资金将在下一次验证者扫描期间自动转移到提款地址。 要重新质押以太币，必须激活新的验证者。 ## 延伸阅读 {#further-reading} diff --git a/src/data/community-events.json b/src/data/community-events.json index 1d15eb13487..ea9d7e080dc 100644 --- a/src/data/community-events.json +++ b/src/data/community-events.json @@ -1,4 +1,13 @@ [ + { + "title": "ETHKL 2023", + "to": "https://hack.ethkl.org/", + "sponsor": null, + "location": "Kuala Lumpur, Malaysia", + "description": "Ethereum Kuala Lumpur 2023 is a Conference & Hackathon aimed at the objective of promoting the understanding and adoption of Ethereum smart contracts and related technologies.", + "startDate": "2023-10-13", + "endDate": "2023-10-15" + }, { "title": "ETHVietnam", "to": "https://www.eth-vietnam.com/", @@ -48,10 +57,10 @@ "title": "AB-Summit", "to": "https://blockchainsummit.africa", "sponsor": null, - "location": "Accra, Ghana", - "description": "Solutions For Disempowered Economies. We support the Blockchain revolution and we are establishing a movement to promote its use out of love for our African Continent and the nations that make it up.", - "startDate": "2023-08-26", - "endDate": "2023-08-27" + "location": "University Of Ghana - Legon. Accra, Ghana", + "description": "Building Blockchains for Africa's Future. We support the Blockchain revolution and we are establishing a movement to promote its use out of love for our African Continent and the nations that make it up.", + "startDate": "2023-10-27", + "endDate": "2023-10-28" }, { "title": "ETH Montréal", @@ -232,5 +241,23 @@ "description": "ETH Munich is a first time Hackathon organised by the local web3 community PretzelDAO", "startDate": "2023-08-11", "endDate": "2023-08-13" + }, + { + "title": "EthCC 6", + "to": "https://www.ethcc.io/", + "sponsor": null, + "location": "Paris, France", + "description": "The Ethereum Community Conference (EthCC) is the largest annual European Ethereum event focused on technology and community. Four intense days of conferences, networking and learning.", + "startDate": "2023-07-17", + "endDate": "2023-07-20" + }, + { + "title": "ETHLisbon 2023", + "to": "https://www.ethlisbon.org/", + "sponsor": null, + "location": "Gale patio, Lisbon, Portugal", + "description": "ETHLisbon is an Ethereum-focused hackathon bringing together the best Web 3.0 builders to the crypto capital of Europe.", + "startDate": "2023-11-03", + "endDate": "2023-11-05" } ] diff --git a/src/data/community-meetups.json b/src/data/community-meetups.json index 9f38868bf16..8e1aed904cf 100644 --- a/src/data/community-meetups.json +++ b/src/data/community-meetups.json @@ -1,4 +1,10 @@ [ + { + "title": "852dev.xyz", + "emoji": ":hong_kong:", + "location": "Hong Kong", + "link": "https://twitter.com/852devxyz" + }, { "title": "Ethereum Ecuador", "emoji": ":ec:", @@ -7,7 +13,7 @@ }, { "title": "Kyiv Ethereum", - "emoji": ":ukr:", + "emoji": "🇺🇦", "location": "Ukraine", "link": "https://kyivethereum.com/" }, diff --git a/src/data/staking-products.json b/src/data/staking-products.json index 9137923aa0a..9a1e1963ae6 100644 --- a/src/data/staking-products.json +++ b/src/data/staking-products.json @@ -157,7 +157,12 @@ "hue": 221, "launchDate": "2021-06-05", "url": "https://eth-docker.net", - "audits": [], + "audits": [ + { + "name": "Sigma Prime", + "url": "https://eth-docker.net/About/SecurityAudit" + } + ], "minEth": 32, "isFoss": true, "hasBugBounty": false, @@ -466,14 +471,14 @@ "hasBugBounty": false, "isTrustless": false, "isPermissionless": false, - "pctMajorityExecutionClient": null, + "pctMajorityExecutionClient": 0, "pctMajorityConsensusClient": 0, "isSelfCustody": true, "platforms": ["Browser"], "ui": ["GUI"], "socials": { - "discord": "https://discord.io/ethermine", - "twitter": "https://twitter.com/ethermine_org" + "discord": "https://discord.io/ethpool", + "twitter": "https://twitter.com/ethpool_staking" }, "matomo": { "eventCategory": "StakingProductCard", @@ -931,53 +936,6 @@ "eventAction": "Clicked", "eventName": "Clicked Bedrock go to link" } - }, - { - "name": "Origin Ether", - "imageName": "OriginEther", - "hue": 211, - "launchDate": "2023-05-16", - "url": "https://oeth.com/", - "audits": [ - { - "name": "OpenZeppelin Security", - "url": "https://github.com/OriginProtocol/security/blob/master/audits/OpenZeppelin%20-%20Origin%20Dollar%20OETH%20Integration%20-%20May%202023.pdf" - }, - { - "name": "Narya.ai", - "url": "https://github.com/OriginProtocol/security/blob/master/audits/Narya%20-%20Origin%20OETH%20Report%20-%20May%202023%20-%20Initial%20Report.pdf" - } - ], - "minEth": 0, - "feePercentage": 20, - "tokens": [ - { - "name": "Origin Ether", - "symbol": "OETH", - "address": "0x856c4efb76c1d1ae02e20ceb03a2a6a08b0b8dc3" - } - ], - "isFoss": true, - "hasBugBounty": true, - "isTrustless": true, - "hasPermissionlessNodes": true, - "pctMajorityClient": null, - "platforms": ["Browser"], - "ui": ["GUI"], - "socials": { - "discord": "https://discord.com/invite/ogn", - "twitter": "https://twitter.com/OriginProtocol", - "github": "https://github.com/originprotocol", - "linkedin": "https://www.linkedin.com/company/originprotocol/", - "youtube": "https://www.youtube.com/c/originprotocol", - "medium": "https://blog.originprotocol.com/", - "telegram": "https://t.me/originprotocol" - }, - "matomo": { - "eventCategory": "StakingProductCard", - "eventAction": "Clicked", - "eventName": "Clicked Origin Ether go to link" - } } ] } diff --git a/src/data/wallets/wallet-data.ts b/src/data/wallets/wallet-data.ts index 4f48dcc45a7..cedbadaf06f 100644 --- a/src/data/wallets/wallet-data.ts +++ b/src/data/wallets/wallet-data.ts @@ -1596,7 +1596,7 @@ const walletData: WalletData[] = [ non_custodial: true, security_audit: [""], scam_protection: true, - hardware_support: false, + hardware_support: true, walletconnect: true, rpc_importing: false, nft_support: true, diff --git a/src/intl/ar/page-wallets-find-wallet.json b/src/intl/ar/page-wallets-find-wallet.json index 19eed25072e..581c5df7fb1 100644 --- a/src/intl/ar/page-wallets-find-wallet.json +++ b/src/intl/ar/page-wallets-find-wallet.json @@ -7,10 +7,88 @@ "page-find-wallet-meta-title": "العثور على محفظة إثيريوم", "page-find-wallet-title": "البحث عن محفظة", "page-find-wallet-try-removing": "حاول إزالة ميزة أو اثنين", + "page-find-wallet-choose-to-compare": "اختر للمقارنة", "page-stake-eth": "تجميد عملات إثير", - "page-find-wallet-swaps": "مبادلات الرموز اللامركزية", - "page-find-wallet-swaps-desc": "التجارة بين إثير والرموز الأخرى مباشرة من محفظتك.", - "page-find-wallet-multisig": "حسابات التوقيع المتعدد", - "page-find-wallet-multisig-desc": "لمزيد من الأمان، تتطلب المحافظ متعددة التوقيع أكثر من حساب واحد لتفويض معاملات معينة.", - "page-find-wallet-showing": "عرض " + "page-find-wallet-open-source": "مفتوح المصدر", + "page-find-wallet-open-source-desc": "البرمجيات مفتوحة المصدر تتيح لأي شخص تدقيق سلامة التطبيق وأمنه", + "page-find-wallet-self-custody": "Self custody", + "page-find-wallet-non-custodial": "المحافظ الساخنة", + "page-find-wallet-non-custodial-desc": "المحافظ التي لا تتحكم في مفاتيحك الخاصة", + "page-find-wallet-hardware-wallet-support": "دعم محفظة الأجهزة", + "page-find-wallet-hardware-wallet-support-desc": "المحافظ التي تستطيع الاتصال بمحفظة الأجهزة للحصول على أمان أفضل", + "page-find-wallet-walletconnect": "WalletConnect", + "page-find-wallet-walletconnect-desc": "المحافظ التي تدعم WalletConnect للاتصال بالتطبيقات اللامركزية", + "page-find-wallet-rpc-importing": "استيراد RPC", + "page-find-wallet-rpc-importing-desc": "المحافظ التي تدعم نقاط نهاية RPC المخصصة للاتصال بعقد أو شبكات مختلفة", + "page-find-wallet-nft-support": "دعم NFT", + "page-find-wallet-nft-support-desc": "المحافظ التي تدعم عرض NFT الخاصة بك والتفاعل معها", + "page-find-wallet-connect-to-dapps": "الاتصال بالتطبيقات اللامركزية", + "page-find-wallet-connect-to-dapps-desc": "المحافظ التي تتصل بالتطبيقات المبنية على شبكة إيثيريوم", + "page-find-wallet-staking": "تجميد العملات", + "page-find-wallet-staking-desc": "حصة ETH مباشرة من المحفظة", + "page-find-wallet-swaps": "المبادلات", + "page-find-wallet-swaps-desc": "مبادلة رموز ERC-20 مباشرة في المحفظة", + "page-find-wallet-layer-2": "الطبقة ٢", + "page-find-wallet-layer-2-desc": "المحافظ التي تدعم طبقة إثيريوم 2s", + "page-find-wallet-gas-fee-customization": "تخصيص رسم الغاز", + "page-find-wallet-gas-fee-customization-desc": "تخصيص مبالغ الغاز الخاصة بك (رسم أساسي، ورسم الأولوية، ورسم الحد الأقصى)", + "page-find-wallet-ens-support": "دعم ENS", + "page-find-wallet-ens-support-desc": "المحافظ التي تدعم خدمة اسم الإيثيريوم (ENS)", + "page-find-wallet-token-importing": "استيراد الرمز المميز", + "page-find-wallet-token-importing-desc": "قم باستيراد أي رمز ERC-20 مميز لاستخدامه في المحفظة", + "page-find-wallet-fee-optimization": "تحسين الرسم", + "page-find-wallet-fee-optimization-desc": "دعم معاملات النوع 2 لرسوم الغاز المحسّنة، واسترداد رسم الغاز غير المستخدم", + "page-find-wallet-buy-crypto": "شراء العملات المشفرة", + "page-find-wallet-buy-crypto-desc": "شراء العملات المشفرة باستخدام العملات الورقية مباشرة في المحفظة \n *ملاحظة: قد يكون شراء العملات المشفرة محددًا بالمنطقة", + "page-find-wallet-sell-for-fiat": "بيع مقابل العملات الورقية", + "page-find-wallet-sell-for-fiat-desc": "بيع العملات المشفرة مقابل العملات الورقية مباشرة في المحفظة \n *ملاحظة: قد يكون سحب العملات المشفرة محددًا بالمنطقة", + "page-find-wallet-multisig": "متعدد التوقيعات (Multisig)", + "page-find-wallet-multisig-desc": "المحافظ التي تتطلب توقيعات متعددة لتفويض معاملة", + "page-find-wallet-social-recovery": "التعافي الاجتماعي", + "page-find-wallet-social-recovery-desc": "محافظ تسمح للأوصياء بتغيير مفتاح التوقيع لمحافظ العقد الذكي", + "page-find-wallet-token-support": "دعم الرمز المميز", + "page-find-wallet-features": "الخصائص", + "page-find-wallet-security": "الأمن", + "page-find-wallet-smart-contract": "Smart contract", + "page-find-wallet-check-out": "Check out", + "page-find-wallet-info-updated-on": "تم تحديث المعلومات في", + "page-find-wallet-showing-all-wallets": "عرض جميع المحافظ", + "page-find-wallet-showing": "عرض ", + "page-find-wallet-wallets": "المحافظ الإلكترونية", + "page-find-wallet-iOS": "iOS", + "page-find-wallet-android": "أندرويد", + "page-find-wallet-linux": "لينكس", + "page-find-wallet-macOS": "macOS", + "page-find-wallet-windows": "ويندوز", + "page-find-wallet-chromium": "الكروميوم", + "page-find-wallet-firefox": "فايرفوكس", + "page-find-wallet-hardware": "معدات الجهاز", + "page-find-wallet-hardware-desc": "محافظ الأجهزة", + "page-find-wallet-new-to-crypto-title": "جديد في العملات المشفرة", + "page-find-wallet-new-to-crypto-desc": "أنت مستخدم لأول مرة تبحث عن محفظتك الأولى", + "page-find-wallet-nfts-title": "NFTs", + "page-find-wallet-nfts-desc": "أنت شخص يهتم بـ NFT وتريد محفظة مع دعم NFT", + "page-find-wallet-hodler-title": "هودلر", + "page-find-wallet-hodler-desc": "أنت شخص لديه رموز مميزة ولا تريد لمسها", + "page-find-wallet-finance-title": "التمويل", + "page-find-wallet-finance-desc": "أنت شخص يستخدم DeFi وتريد محفظة تتيح لك الاتصال بتطبيقات DeFi", + "page-find-wallet-developer-title": "مبرمج", + "page-find-wallet-developer-desc": "أنت مبرمج وتحتاج إلى محفظة للمساعدة في تطوير واختبار التطبيقات اللامركزية", + "page-find-wallet-persona-desc": "اختر الملف الشخصي الذي يتطابق مع نوع المستخدم الخاص بك وقم بتصفية قائمة المحفظة", + "page-find-wallet-filters": "عوامل التصفية", + "page-find-wallet-active": "نشط", + "page-find-wallet-profile-filters": "عوامل تصفية الملف الشخصي", + "page-find-wallet-feature-filters": "عوامل تصفية الميزات", + "page-find-wallet-footnote-1": "المحافظ المدرجة في هذه الصفحة ليست مصادقات رسمية، ويتم توفيرها للأغراض الإعلامية فقط.", + "page-find-wallet-footnote-2": "تم توفير أوصافها من خلال مشاريع المحفظة نفسها.", + "page-find-wallet-footnote-3": "نحن نضيف منتجات إلى هذه الصفحة استنادًا إلى معايير في سياسة الإدراج لدينا. إذا كنت تريد منا إضافة محفظة، قم بطرح استفسار في GitHub.", + "page-find-wallet-mobile": "جوال", + "page-find-wallet-mobile-desc": "محافظ مع تطبيقات الجوال", + "page-find-wallet-desktop": "سطح المكتب", + "page-find-wallet-desktop-desc": "محافظ مع تطبيقات سطح المكتب", + "page-find-wallet-browser": "المتصفح", + "page-find-wallet-browser-desc": "محافظ مع ملحقات المتصفح", + "page-find-wallet-device": "جهاز", + "page-find-choose-to-compare": "اختر للمقارنة", + "page-find-wallet-choose-features": "اختر الميزات" } diff --git a/src/intl/ar/page-wallets.json b/src/intl/ar/page-wallets.json index 1280bea0de2..0140ba0eb86 100644 --- a/src/intl/ar/page-wallets.json +++ b/src/intl/ar/page-wallets.json @@ -61,5 +61,7 @@ "page-wallets-your-ethereum-account": "حساب الإثيريوم الخاص بك", "page-wallets-your-ethereum-account-desc": "محفظتك هي نافذتك في حساب إيثيريوم الخاص بك - رصيدك، وتاريخ معاملاتك وأكثر. ولكن يمكنك تغيير موفري المحفظة في أي وقت.", "page-wallets-your-login": "تسجيل الدخول الخاص بك لتطبيقات إثيريوم", - "page-wallets-your-login-desc": "تتيح لك محفظتك الاتصال بأي تطبيق لامركزي باستخدام حساب إثيريوم الخاص بك. إنه مثل تسجيل الدخول الذي يمكنك استخدامه عبر العديد من التطبيقات اللامركزية." + "page-wallets-your-login-desc": "تتيح لك محفظتك الاتصال بأي تطبيق لامركزي باستخدام حساب إثيريوم الخاص بك. إنه مثل تسجيل الدخول الذي يمكنك استخدامه عبر العديد من التطبيقات اللامركزية.", + "additional-reading-how-to-register-an-ethereum-account": "كيفية \"تسجيل\" حساب إثيريوم", + "additional-reading-how-to-use-a-wallet": "كيفية استخدام محفظة" } diff --git a/src/intl/ar/page-what-is-ethereum.json b/src/intl/ar/page-what-is-ethereum.json index 94839f93ced..534d2030c81 100644 --- a/src/intl/ar/page-what-is-ethereum.json +++ b/src/intl/ar/page-what-is-ethereum.json @@ -32,23 +32,23 @@ "page-what-is-ethereum-cryptocurrency-tab-title": "لماذا تسمى بالعملة الرقمية؟", "page-what-is-ethereum-cryptocurrency-tab-content": "تستخدم سلاسل الكتل تقنيات التشفير للتأكد من أن أموالك آمنة. وقد استخدمت تقنيات مماثلة في الصناعات المصرفية لضمان أمن المعاملات النقدية لسنوات عديدة. لذا يمكنك أن تقول أن العملات الرقمية لديها مستوى من الأمان البنكي.", "page-what-is-ethereum-summary-title": "ملخص", - "page-what-is-ethereum-summary-desc-1": "إيثيريوم هي تكنولوجيا لبناء التطبيقات والمنظمات وحيازة الأصول والمعاملات والاتصالات دون أن تخضع لرقابة سلطة مركزية. ليس هناك حاجة لتسليم جميع بياناتك الشخصية لاستخدام الإيثيريوم - يمكنك التحكم في بياناتك الخاصة وما يتم مشاركته. لدى إيثيريوم عملة رقمية خاصة بها، Ether، والتي تستخدم لدفع ثمن أنشطة معينة على شبكة إيثيريوم.", + "page-what-is-ethereum-summary-desc-1": "إثيريوم هي شبكة مكونة من العديد من المجتمعات، ومجموعة من الأدوات التي تمكّن الأشخاص من التعامل والتواصل دون أن يخضعوا لسيطرة من سلطة مركزية. ليس هناك حاجة لتسليم جميع تفاصيلك الشخصية لاستخدام إثيريوم، يمكنك الاحتفاظ بالتحكم في بياناتك الخاصة وما يتم مشاركته. لدى إثيريوم عملة رقمية خاصة بها، Ether، والتي تستخدم لدفع ثمن أنشطة معينة على شبكة إثيريوم.", "page-what-is-ethereum-summary-desc-2": "لا تزال مرتبكًا؟ لنشرح كل شيء خطوة بخطوة.", "page-what-is-ethereum-what-is-crypto-title": "ما العملة الرقمية؟", "page-what-is-ethereum-what-is-crypto-desc-1": "العملات المشفرة (اختصار للعملة الرقمية) هي شكل جديد من الأموال الرقمية المدعومة بالتشفير.", "page-what-is-ethereum-what-is-crypto-desc-2": "بدأ كل ذلك في عام 2008 مع عملة بيتكوين. يمكنك استخدامها لإرسال الأموال لأي شخص في أي مكان في العالم. ما جعل العملات المشفرة مختلفة عن التحويلات المصرفية العادية أو غيرها من الخدمات المالية مثل Paypal أو Alipay هو أنه لا يوجد وسيط لأول مرة.", "page-what-is-ethereum-what-is-crypto-desc-3": "مهلًا، من الوسيط؟", - "page-what-is-ethereum-what-is-crypto-desc-4": "الرجل الوسيط هو سلطة مركزية مثل المصرف أو جهة حكومية تتدخل في صفقة بين المرسل والمتلقي. لديهم سلطة مراقبة الصفقات أو الرِّقابة عليها أو الرجوع عنها ويمكنهم تقاسم البيانات الحساسة التي يجمعوها عنك مع أطراف ثالثة. غالبًا ما تفرض أيضًا الخدمات المالية التي يمكنك الوصول إليها.", + "page-what-is-ethereum-what-is-crypto-desc-4": "الوسيط هو سلطة مركزية مثل البنك أو الحكومة، تتدخل في معاملة بين المرسل والمتلقي. ولديها القدرة على مراقبة المعاملات، أو الرقابة عليها، أو التراجع عنها، ويمكنها مشاركة البيانات الحساسة التي تجمعها عنك مع أطراف ثالثة. وغالبًا ما تملي أيضًا الخدمات المالية التي يمكنك الوصول إليها.", "page-what-is-ethereum-what-is-crypto-desc-5": "تختلف الأمور مع العملات المشفرة.المعاملات تربط المرسل والمتلقي مباشرةدون الحاجة إلى التعامل مع أي سلطة مركزية. لن يتمكن أي طرف آخر من الوصول إلى أموالك ولا يستطيع أحد أن يخبرك عن الخِدْمَات التي يمكنك استخدامها. بسبب تِقَانَة سلاسل الكتل التي تعمل عليها العملات الرقمية.", "page-what-is-ethereum-btc-eth-diff-title": "ما الفرق بين الإيثيريوم وعملة بيتكوين؟", "page-what-is-ethereum-btc-eth-diff-1": "تم إطلاق الإثيريوم في عام 2015، وهو مستوحى من فكرة عملة بيتكوين، مع بعض الاختلافات الكبيرة.", "page-what-is-ethereum-btc-eth-diff-2": "كلاهما يسمح لك باستخدام المال الرقمي دون اللجوء لموفري الدفع أو البنوك. لكن الإيثيريوم قابل للبرمجة، لذا يمكنك استخدامه أيضًا في بناء ونشر التطبيقات اللامركزية على شبكته.", - "page-what-is-ethereum-btc-eth-diff-3": "الإيثيريوم قابل للبرمجة ما يعني أنه يمكنك إنشاء تطبيقات تستخدم سلسلة الكتل لتخزين البيانات أو التحكم في ما يمكن أن يفعله تطبيقك. هذا يؤدي إلى سلسلة الكتل ذات الغرض العام التي يمكن برمجتها لفعل أي شيء. بما أنه لا يوجد حدود لما يمكن أن يفعله الإيثيريوم، فإنه يسمح بالابتكار العظيم أن يحدث على شبكة الإيثيريوم.", + "page-what-is-ethereum-btc-eth-diff-3": "تمكننا عملة بيتكوين من إرسال رسائل أساسية لبعضنا البعض حول ما نعتقد أنه ذو قيمة. إن تأسيس القيمة دون سلطة هو أمر قوي بالفعل. توسع إيثريوم من هذه الإمكانية: بدلاً من مجرد الرسائل، يمكنك كتابة أي برنامج عام، أو عقد. وليس هناك حد لنوع العقود التي يمكن إنشاؤها والاتفاق عليها، ومن ثم يحدث ابتكار كبير على شبكة إيثيريوم.", "page-what-is-ethereum-btc-eth-diff-4": "بينما عملة بيتكوين هي فقط شبكة دفع، فإن الإيثيريوم يشبه سوق الخِدْمَات المالية، الألعاب، والشبكات الاجتماعية والتطبيقات الأخرى الذي تحترم خصوصيتك ولا يمكن أن تراقبك.", "page-what-is-ethereum-what-can-eth-do-title": "ما الذي يمكن للإيثيريوم أن يفعله؟", "page-what-is-ethereum-why-would-i-use-ethereum-title": "لماذا يجب أن أستخدم الإيثيريوم؟", "page-what-is-ethereum-why-would-i-use-ethereum-1": "إذا كنت قد أرسلت أموالًا إلى الخارج (أو تخطط لذالك)، أو اضطرت إلى القلق بشأن مستقبل أصولك بسبب قوى خارجية خارجة عن سيطرتك حيث تعيش، أو يجب تحمل القيود والرسوم العديدة التي تفرضها المؤسسات المالية التقليدية على المعاملات اليومية، قد تكون مهتمًا بما تقدمه العملات الرقمية.", - "page-what-is-ethereum-why-would-i-use-ethereum-2": "ضع في اعتبارك أن الإيثيريوم لا يزال جديدًا، وسيتم الكشف عن كثير من الأسباب الأخرى لاستخدامه مع التطور ومرور الوقت.", + "page-what-is-ethereum-why-would-i-use-ethereum-2": "إذا كنت مهتمًا بطرق أكثر مرونة وانفتاحًا وجديرة بالثقة لتأسيس القيمة ومشاركتها، فإن إثيريوم هي الخيار الأمثل لك. إثيريوم هي قصة كتبناها جميعًا، لذا تعال واكتشف العوالم المذهلة التي يمكننا أن نبنيها معًا.", "page-what-is-ethereum-slide-1-title": "المدفوعات عبر الحدود أرخص وأسرع", "page-what-is-ethereum-slide-1-desc-1": "العملات التابعة هي نوع جديد من العملات الرقمية التي تعتمد على أصل أكثر استقرارًا كأساس لقيمتها. ويرتبط معظمها بدولار الولايات المتحدة ثَمّ تحافظ على قيمة تلك العملة. وتسمح لنظام دفع عالمي رخيص للغاية ومستقر. تم بناء العديد من العملات التابعة الحالية على شبكة الإيثيريوم.", "page-what-is-ethereum-slide-1-desc-2": "وتبسِّط الإيثيريوم والعملات التابعة عملية إرسال الأموال إلى الخارج. وكثيرًا ما يستغرق نقل الأموال عبر العالم بضع دقائق فحسب. على عكس عدد أيام العمل أو حتى الأسابيع التي قد يستغرقها البنك العادي، ولجزء من السعر. وبالإضافة إلى ذلك، لا يوجد رسم إضافي لإجراء معاملة عالية القيمة، وهناك قيود صفرية على مكان أو سبب إرسال أموالك.", @@ -84,15 +84,34 @@ "page-what-is-ethereum-criminal-activity-desc-2": "تستخدم العملات المشفّرة بنسبة أقل بكثير من العملات الورقيّة لغايات إجراميّة وفقًا لنتائج تقرير حديث صادر عن اليوروبول، وكالة الاتحاد الأوروبي للتعاون في مجال تطبيق القانون:", "page-what-is-ethereum-criminal-activity-desc-3": "\"يبدو أن استخدام العملات الرقمية في الأنشطة غير المشروعة لا يشكّل إلّا جزء صغير فقط من الاقتصاد الكلّي للعملة الرقمية، كما يبدو أنه صغير نسبيًّا مقارنة بكميّة الأرصدة غير المشروعة الموجودة بالنظام المالي التقليدي.\"", "page-what-is-ethereum-energy-title": "ما عن استهلاك شبكة الإيثيريوم للطاقة؟", - "page-what-is-ethereum-energy-desc-1": "تستخدم شبكة الإيثريوم حاليًا آلية إثبات العمل لتأكيد المعاملات وهذه الآلية تستهلك كميّة كبيرة من الطاقة. ستخضع إيثريوم في الأشهر القادمة (الربع الثالث/الربع الرابع 2022) لأكبر تحديث في تاريخها الذي سيحوّل آلية عمل الشبكة في تأكيد المعاملات إلى آلية إثبات الحصّة التي ستقلّل كثيرًا من التأثير البيئيالذي تحدثه آلية إثبات العمل.", - "page-what-is-ethereum-energy-desc-2": "سيقلّل هذا التحديث الطاقة المطلوبة لتأمين شبكة الإيثيريوم بحوالي 99.95%، مما يساهم في تكوينشبكة أكثر أمنًا مع تكلفة كربون أقل كثيرًا. هذا سيجعل من إيثيريوم سلسلة كتل قليلة المساهمة في إصدار الكربون بشكل جدّي بينما تقوم في نفس الوقت بتعزيز أمنها وقابليتها للتوسّع.", + "page-what-is-ethereum-energy-desc-1": "في 15 سبتمبر/أيلول 2022، اجتازت إثيريوم ترقية الدمج التي انتقلت بإثيريوم من إثبات العمل إلى إثبات الحصة.", + "page-what-is-ethereum-energy-desc-2": "كانت عملية الدمج هي أكبر ترقية لإثيريوم و قللت من طاقة الاستهلاك المطلوبة لتأمين إثيريوم بنسبة 99.95%، مما ساهم في إنشاء شبكة أكثر أمنا من أجل تكلفة كربونية أقل بكثير. تعد إثيريوم الآن سلسلة كتل منخفضة الكربون بينما تقوم بتعزيز أمنها و قابليتها للتوسع.", "page-what-is-ethereum-more-on-energy-consumption": "للمزيد حول استهلاك الطاقة", - "page-what-is-ethereum-energy-consumption-chart-legend": "الاستهلاك السنوي للطاقة مقدّرًا بتيراواط/بالسنة", + "page-what-is-ethereum-energy-consumption-chart-legend": "الاستهلاك السنوي للطاقة مقدّرًا بتيرا واط ساعة/السنة", + "energy-consumption-chart-global-data-centers-label": "المراكز العالمية للبيانات", + "energy-consumption-gold-mining-cbeci-label": "Gold mining", + "energy-consumption-chart-btc-pow-label": "بيتكوين PoW", + "energy-consumption-chart-netflix-label": "نتفلكس", + "energy-consumption-chart-eth-pow-label": "بيتكوين ETH", + "energy-consumption-chart-gaming-us-label": "الألعاب في الولايات المتحدة", + "energy-consumption-chart-paypal-label": "بابيال", + "energy-consumption-chart-eth-pos-label": "ETH PoS", "page-what-is-ethereum-the-merge-update": "تحديث دمج", "page-what-is-ethereum-additional-reading": "قراءة مزيد", "page-what-is-ethereum-week-in-ethereum": "أسبوع من أخبار الإيثريوم", "page-what-is-ethereum-week-in-ethereum-desc": "-رسالة إخبارية أسبوعية تغطي التطورات الرئيسية عبر النظام البيئي.", + "page-what-is-ethereum-kernel-dreamers": "Kernel", + "page-what-is-ethereum-kernel-dreamers-desc": "حلم إثيريوم", "page-what-is-ethereum-atoms-institutions-blockchains": "الذرات والمؤسسات وسلاسل الكتل", "page-what-is-ethereum-atoms-institutions-blockchains-desc": "-لماذا سلاسل الكتل مهمة؟", - "page-what-is-ethereum-ethereum-in-numbers-title": "إيثيريوم بالأرقام" + "page-what-is-ethereum-ethereum-in-numbers-title": "إيثيريوم بالأرقام", + "adoption-chart-column-now-label": "الآن", + "adoption-chart-investors-label": "المستثمرون", + "adoption-chart-developers-label": "المبرمجون", + "adoption-chart-companies-label": "الشركات", + "adoption-chart-artists-label": "الفنانون", + "adoption-chart-musicians-label": "الموسيقيون", + "adoption-chart-writers-label": "الكُتّاب", + "adoption-chart-gamers-label": "اللاعبون", + "adoption-chart-refugees-label": "اللاجئون" } diff --git a/src/intl/az/common.json b/src/intl/az/common.json index cea153e02c8..b67298f5eaa 100644 --- a/src/intl/az/common.json +++ b/src/intl/az/common.json @@ -13,6 +13,7 @@ "community-hub": "İcma mərkəzi", "community-menu": "İcma Menyusu", "contact": "Əlaqə", + "content-standardization": "Məzmun standartlaşdırılması", "contributing": "Töhfələr", "contributors": "Töhfəçilər", "contributors-thanks": "Bu səhifədə əməyi olan hər kəsə - təşəkkür edirik!", @@ -28,7 +29,24 @@ "developers": "Tərtibatçılar", "developers-home": "Tərtibatçıların Ana Səhifəsi", "docs": "Sənədlər", + "docsearch-to-select": "Seçmək", + "docsearch-to-navigate": "Naviqasiya", + "docsearch-to-close": "Bağlamaq", + "docsearch-search-by": "Axtar:", + "docsearch-start-recent-searches-title": "Ən son", + "docsearch-start-no-recent-searches": "Son axtarışlar yoxdur", + "docsearch-start-save-recent-search": "Bu axtarışı yadda saxlayın", + "docsearch-start-remove-recent-search": "Bu axtarışı tarixçədən silin", + "docsearch-start-favorite-searches": "Seçilmiş", + "docsearch-start-remove-favorite-search": "Bu axtarışı seçilmişdən silin", + "docsearch-no-results-text": "Nəticə yoxdur:", + "docsearch-no-results-suggested-query": "Axtarmağa çalışın:", + "docsearch-no-results-missing": "İnanırsınız ki, bu sorğu nəticə verməlidir?", + "docsearch-no-results-missing-link": "Bizə bildirin.", + "docsearch-error-title": "Nəticələri əldə etmək mümkün deyil", + "docsearch-error-help": "Şəbəkə bağlantınızı yoxlayın.", "documentation": "Sənədləşdirmə", + "down": "Aşağı", "ecosystem": "Ekosistem", "edit-page": "Səhifəni redaktə et", "ef-blog": "Ethereum Fondu üzrə Bloq", @@ -69,7 +87,6 @@ "get-started": "Başla", "grants": "Qrantlar", "grant-programs": "Ekosistem dəstək proqramları", - "guides-and-resources": "İcma üzrə təlimat və resurslar", "guides": "Bələdçilər", "guides-hub": "Bələdçi mərkəzi", "history-of-ethereum": "Ethereumun tarixi", @@ -93,6 +110,7 @@ "layer-2": "2-ci Qrup", "learn": "Öyrən", "learn-by-coding": "Kodlaşdırma yolu ilə öyrən", + "learn-hub": "Öyrənmə mərkəzi", "learn-menu": "Menyunu öyrən", "learn-more": "Daha ətraflı", "less": "Daha az", @@ -124,6 +142,7 @@ "rollup-component-technology-and-risk-summary": "Texnologiya və risk icmalı", "scaling": "Ölçəkləmə", "search": "Axtarış", + "search-ethereum-org": "Ethereum.org-da axtarın", "secret-leader-election": "Gizli lider seçimi", "search-box-blank-state-text": "Axtarış et!", "search-eth-address": "Bu, Ethereum ünvanına bənzəyir. Biz ünvanlar üçün xüsusi məlumat təqdim etmirik. Gərəkli məlumatları blok tədqiqatçılarında tapmağa çalışın, məsələn:", @@ -140,7 +159,9 @@ "skip-to-main-content": "Əsas məzmuna keç", "smart-contracts": "Ağıllı müqavilələr", "stablecoins": "Stabil koinlər", + "stake-eth": "ETH-ni steyk", "staking": "Steykinq", + "style-guide": "Style guide", "solo": "Solo steykinq", "saas": "Bir xidmət kimi steykinq", "pools": "Birləşdirilmiş steykinq", @@ -157,6 +178,7 @@ "translation-banner-no-bugs-dont-show-again": "Bir daha göstərmə", "try-using-search": "Axtardığınızı tapmaq üçün axtarışdan istifadə etməyə çalışın və ya", "tutorials": "Təlimatlar", + "up": "Yuxarı", "use-ethereum": "Ethereum istifadə et", "use-ethereum-menu": "Ethereum menyusunu istifadə et", "user-experience": "İstifadəçi təcrübəsi", @@ -176,5 +198,6 @@ "yes": "Bəli", "zero-knowledge-proofs": "Sıfır bilik verməklə isbat protokolu", "ethereum-roadmap": "Ethereum planlama xəritəsi", - "page-index-meta-title": "Əsas səhifə" + "page-index-meta-title": "Home", + "page-developers-aria-label": "Developers' Menu" } diff --git a/src/intl/az/page-dapps.json b/src/intl/az/page-dapps.json index 9f8a3e0e2bb..33a5a76ba3f 100644 --- a/src/intl/az/page-dapps.json +++ b/src/intl/az/page-dapps.json @@ -1,4 +1,217 @@ { + "page-dapps-1inch-logo-alt": "1inch loqosu", + "page-dapps-dexguru-logo-alt": "DexGuru loqosu", + "page-dapps-aave-logo-alt": "Aave loqosu", + "page-dapps-add-button": "MT təklif edin", + "page-dapps-add-title": "MT əlavə edin", + "page-dapps-audius-logo-alt": "Audius loqosu", + "page-dapps-augur-logo-alt": "Augur loqosu", + "page-dapps-axie-infinity-logo-alt": "Axie Infinity loqosu", + "page-dapps-balancer-logo-alt": "Balancer loqosu", + "page-dapps-brave-logo-alt": "Brave loqosu", + "page-dapps-category-arts": "İncəsənət və moda", + "page-dapps-category-browsers": "Brauzerlər", + "page-dapps-category-collectibles": "Rəqəmsal kolleksiyalar", + "page-dapps-category-competitive": "Müsabiqə", + "page-dapps-category-computing": "Developer tools", + "page-dapps-category-dex": "Token mübadilələri", + "page-dapps-category-investments": "İnvestisiyalar", + "page-dapps-category-lending": "Kredit vermək və borc vermək", + "page-dapps-category-lottery": "Kraudfanding", + "page-dapps-category-marketplaces": "Bazar yerləri", + "page-dapps-category-music": "Musiqi", + "page-dapps-category-payments": "Ödənişlər", + "page-dapps-category-insurance": "Sığorta", + "page-dapps-category-portfolios": "Portfoliolar", + "page-dapps-category-trading": "Ticarət və proqnoz bazarları", + "page-dapps-category-utilities": "Infrastruktur", + "page-dapps-category-worlds": "Virtual dünyalar", + "page-dapps-choose-category": "Kateqoriya seçin", + "page-dapps-collectibles-benefits-1-description": "İncəsənət Ethereum-da tokenləşdirildikdə, sahiblik hamının görməsi üçün sübut edilə bilər. Sənət əsərinin yaradılışından indiki sahibinə qədər olan səyahətini izləyə bilərsiniz. Bu, saxtakarlığın qarşısını alır.", + "page-dapps-collectibles-benefits-1-title": "Mülkiyyət sübut olunur", + "page-dapps-collectibles-benefits-2-description": "Musiqi yayımlamaq və ya sənət əsərləri almaq üçün pul ödəmək sənətçilər üçün daha ədalətlidir. Ethereum ilə vasitəçilərə daha az ehtiyac var. Vasitəçilərə ehtiyac varsa, onların xərcləri o qədər də yüksək deyil, çünki platformaların şəbəkənin infrastrukturu üçün pul ödəməyə ehtiyacı yoxdur.", + "page-dapps-collectibles-benefits-2-title": "Yaradıcılar üçün daha ədalətli", + "page-dapps-collectibles-benefits-3-description": "Tokenləşdirilmiş kolleksiyalar platformaya deyil, Ethereum ünvanınıza bağlıdır. Beləliklə, siz oyundaxili elementlər kimi şeyləri təkcə oyunun özündə deyil, istənilən Ethereum bazarında sata bilərsiniz.", + "page-dapps-collectibles-benefits-3-title": "Kolleksiyalar sizinlə gedir", + "page-dapps-collectibles-benefits-4-description": "Sənətinizi təsdiqləmək və satmaq üçün alətlər və məhsullar artıq mövcuddur! Və tokenləriniz istənilən və bütün Ethereum kolleksiya platformalarında satıla bilər.", + "page-dapps-collectibles-benefits-4-title": "İnfrastruktur artıq hazırdır", + "page-dapps-collectibles-benefits-description": "Bunlar rəqəmsal sahibliyə, yaradıcılar üçün qazanc potensialını artırmağa və sevimli yaradıcılarınıza və onların işinə investisiya etməyin yeni yollarını ixtira etməyə yönəlmiş tətbiqlərdir.", + "page-dapps-collectibles-benefits-title": "mərkəzləşdirilməmiş kolleksiyalar və axın", + "page-dapps-collectibles-button": "İncəsənət və kolleksiyalar", + "page-dapps-collectibles-description": "Bunlar rəqəmsal sahibliyə, yaradıcılar üçün qazanc potensialını artırmağa və sevimli yaradıcılarınıza və onların işinə investisiya etməyin yeni yollarını ixtira etməyə yönəlmiş tətbiqlərdir.", + "page-dapps-collectibles-title": "Mərkəzləşdirilməmiş incəsənət və kolleksiyalar", + "page-dapps-compound-logo-alt": "Compound loqosu", + "page-dapps-cryptopunks-logo-alt": "CryptoPunks loqosu", + "page-dapps-cryptovoxels-logo-alt": "Cryptovoxels loqosu", + "page-dapps-dapp-description-1inch": "Ən yaxşı qiymətləri birləşdirərək yüksək qiymətdən qaçmağa kömək edir.", + "page-dapps-dapp-description-aave": "Faiz qazanmaq və istənilən vaxt geri çəkmək üçün tokenlərinizi borc verin.", + "page-dapps-dapp-description-async-art": "#ProgrammableArt yaradın, toplayın və mübadilə edin - rəqəmsal rəsmlər ümumi təsvirə təsir etmək üçün istifadə edə biləcəyiniz \"Laylara\" bölünür. Hər bir Master və Layer ERC721 tokenidir.", + "page-dapps-dapp-description-audius": "Mərkəzləşdirilməmiş axın platforması. Dinləyir = etiketlər deyil, yaradıcılar üçün pul.", + "page-dapps-dapp-description-augur": "İdman, iqtisadiyyat və digər dünya hadisələrinin nəticələrinə mərc edin.", + "page-dapps-dapp-description-axie-infinity": "Axies adlı ticarət və döyüş canlıları. Oynadıqca qazanın - mobil cihazlarda mövcuddur", + "page-dapps-dapp-description-balancer": "Balancer avtomatlaşdırılmış portfel meneceri və ticarət platformasıdır.", + "page-dapps-dapp-description-brave": "Baxış üçün tokenlər qazanın və onlarla sevimli yaradıcılarınızı dəstəkləyin.", + "page-dapps-dapp-description-cent": "NFT göndərməklə pul qazandığınız sosial şəbəkə.", + "page-dapps-dapp-description-compound": "Faiz qazanmaq və istənilən vaxt geri çəkmək üçün tokenlərinizi borc verin.", + "page-dapps-dapp-description-cryptopunks": "Ethereum-da ilk token kolleksiyalarından biri olan pankları alın, təklif edin və satışa təqdim edin.", + "page-dapps-dapp-description-cryptovoxels": "İncəsənət qalereyaları yaradın, mağazalar tikin və torpaq satın alın – Ethereum virtual dünyası.", + "page-dapps-dapp-description-dark-forest": "Sonsuz, prosedurla yaradılan, kriptoqrafik olaraq müəyyən edilmiş kainatda planetləri fəth edin.", + "page-dapps-dapp-description-decentraland": "Tədqiq edə biləcəyiniz virtual dünyada virtual torpaq toplayın, ticarət edin.", + "page-dapps-dapp-description-ens": "Ethereum ünvanları və mərkəzləşdirilməmiş saytlar üçün istifadəçi üçün uyğun adlar.", + "page-dapps-dapp-description-foundation": "Rəqəmsal sənət əsərlərinin unikal nəşrlərinə investisiya qoyun və digər alıcılarla elemetləri mübadilə edin.", + "page-dapps-dapp-description-gitcoin": "Açıq mənbəli proqram təminatı üzərində işləyərək kripto qazanın.", + "page-dapps-dapp-description-gitcoin-grants": "Gücləndirilmiş töhfələrlə Ethereum icma layihələri üçün kraudfanding", + "page-dapps-dapp-description-gods-unchained": "Strateji ticarət kartı oyunu. Real həyatda sata biləcəyiniz kartları oynayaraq qazanın.", + "page-dapps-dapp-description-golem": "Paylaşılan hesablama gücünə daxil olun və ya öz resurslarınızı icarəyə götürün.", + "page-dapps-dapp-description-radicle": "Vasitəçilər olmadan birəbir kod əməkdaşlığını təmin edin.", + "page-dapps-dapp-description-loopring": "Sürət üçün qurulmuş birəbir ticarət platforması.", + "page-dapps-dapp-description-marble-cards": "URL-lərə əsaslanan unikal rəqəmsal kartları yaradın və ticarət edin.", + "page-dapps-dapp-description-matcha": "Ən yaxşı qiymətləri tapmağınıza kömək etmək üçün bir çox mübadilələri axtarır.", + "page-dapps-dapp-description-nifty-gateway": "Ən yaxşı rəssamlardan, idmançılardan, brendlərdən və yaradıcılardan şəbəkəli şəkildə əsərləri satın alın.", + "page-dapps-dapp-description-oasis": "Ethereum stabilkoini olan Dai ilə ticarət edin, borc alın və qənaət edin.", + "page-dapps-dapp-description-opensea": "Məhdud sayda mal alın, satın, kəşf edin və mübadilə edin.", + "page-dapps-dapp-description-opera": "Brauzerinizdən tacirlərə, digər istifadəçilərə və proqramlara kripto göndərin.", + "page-dapps-dapp-description-poap": "Müxtəlif virtual və ya şəxsi tədbirlərdə olduğunuzu sübut edən NFT-ləri toplayın. Onlardan lotereyaya qoşulmaq, səs vermək, əməkdaşlıq etmək və ya sadəcə lovğalanmaq üçün istifadə edin.", + "page-dapps-dapp-description-polymarket": "Nəticələrə mərc. İnformasiya bazarlarında ticarət.", + "page-dapps-dapp-description-pooltogether": "Uduza bilməyəcəyiniz lotereya. Hər həftə mükafatlar.", + "page-dapps-dapp-description-index-coop": "Portfelinizə ən yaxşı DeFi tokenlərinə məruz qalma imkanı verən kripto indeks fondu.", + "page-dapps-dapp-description-nexus-mutual": "Sığorta şirkəti olmadan sığorta. Ağıllı müqavilə xətalarından və hakerlərdən qorunun.", + "page-dapps-dapp-description-etherisc": "Hər kəsin öz sığorta əhatəsini yaratmaq üçün istifadə edə biləcəyi mərkəzləşdirilməmiş sığorta şablonu.", + "page-dapps-dapp-description-zapper": "Portfelinizi izləyin və bir interfeysdən bir sıra DeFi məhsullarından istifadə edin.", + "page-dapps-dapp-description-zerion": "Portfelinizi idarə edin və sadəcə bazardakı hər bir DeFi aktivini qiymətləndirin.", + "page-dapps-dapp-description-rotki": "Məxfiliyinizə hörmət edən açıq mənbəli portfel izləmə, analitika, mühasibat uçotu və vergi hesabatı aləti.", + "page-dapps-dapp-description-krystal": "Bütün sevimli DeFi xidmətlərinə daxil olmaq üçün bir pəncərə.", + "page-dapps-dapp-description-rarible": "Tokenləşdirilmiş kolleksiya elmentləri yaradın, satın və alın.", + "page-dapps-dapp-description-sablier": "Real vaxtda pul axını.", + "page-dapps-dapp-description-superrare": "Rəqəmsal sənət əsərlərini birbaşa rəssamlardan və ya ikincil bazarlardan alın.", + "page-dapps-dapp-description-token-sets": "Avtomatik olaraq yenidən tarazlaşan kriptovalyuta investisiya strategiyaları.", + "page-dapps-dapp-description-tornado-cash": "Ethereum-da anonim əməliyyatlar göndərin.", + "page-dapps-dapp-description-uniswap": "Tokenləri sadəcə dəyişdirin və ya % mükafat üçün tokenlər təmin edin.", + "page-dapps-dapp-description-dexguru": "DeFi treyderləri üçün girova əsaslanmayan ticarət terminalı", + "page-dapps-docklink-dapps": "Intro to dapps", + "page-dapps-docklink-smart-contracts": "Ağıllı müqavilələr", + "page-dapps-dark-forest-logo-alt": "Dark Forest loqosu", + "page-dapps-decentraland-logo-alt": "Decentraland loqosu", + "page-dapps-index-coop-logo-alt": "Index Coop loqosu", + "page-dapps-nexus-mutual-logo-alt": "Nexus Mutual loqosu", + "page-dapps-etherisc-logo-alt": "Etherisc loqosu", + "page-dapps-zapper-logo-alt": "Zapper loqosu", + "page-dapps-zerion-logo-alt": "Zerion loqosu", + "page-dapps-rotki-logo-alt": "Rotki loqosu", + "page-dapps-krystal-logo-alt": "Krystal loqosu", + "page-dapps-desc": "Sınamaq üçün Ethereum tətbiqini tapın.", + "page-dapps-doge-img-alt": "Kompüterdən istifadə edən itin təsviri", + "page-dapps-editors-choice-dark-forest": "Planetləri fəth etmək üçün başqalarına qarşı oynayın və qabaqcıl Ethereum miqyası/məxfilik texnologiyasını sınayın. Bəlkə Ethereum ilə artıq tanış olanlar üçün.", + "page-dapps-editors-choice-description": "Ethereum.org komandasının hazırda sevdiyi bir neçə mərkəzləşdirilməmiş tətbiq var. Aşağıdakı daha çox mərkəzləşdirilməmiş tətbiqi araşdırın.", + "page-dapps-editors-choice-foundation": "Mədəniyyətə sərmayə qoyun. Bəzi inanılmaz rəssamların, musiqiçilərin və brendlərin unikal rəqəmsal sənət əsərlərini və modasını alın, mübadilə edin və satın.", + "page-dapps-editors-choice-header": "Redaktorların seçimləri", + "page-dapps-editors-choice-pooltogether": "İtkisiz lotereya üçün bilet alın. Hər həftə bütün bilet fondundan əldə edilən faiz bir şanslı qalibə göndərilir. İstədiyiniz zaman pulunuzu geri alın.", + "page-dapps-editors-choice-uniswap": "Tokenlərinizi asanlıqla dəyişdirin. Şəbəkədəki insanlarla token ticarətinə imkan verən icma sevimlisi.", + "page-dapps-ens-logo-alt": "Ethereum Name Service loqosu", + "page-dapps-explore-dapps-description": "Bir çox dapp hələ də eksperimentaldır, mərkəzləşdirilməmiş şəbəkələrin imkanlarını sınaqdan keçirir. Ancaq texnologiya, maliyyə, oyun və kolleksiya kateqoriyalarında bəzi uğurlu erkən köçürmələr var.", + "page-dapps-explore-dapps-title": "Dapps-ı araşdırın", + "page-dapps-features-1-description": "Ethereum-a yerləşdirildikdən sonra dapp kodu silinə bilməz. Və hər kəs mərkəzləşdirilməmiş tətbiq xüsusiyyətlərindən istifadə edə bilər. Mərkəzləşdirilməmiş tətbiqin arxasında olan komanda dağılsa belə, siz hələ də ondan istifadə edə bilərsiniz. Ethereum-da bir dəfə orada qalır.", + "page-dapps-features-1-title": "Sahibləri yoxdur", + "page-dapps-features-2-description": "Heç kim sizə mərkəzləşdirilməmiş tətbiqdən istifadə etməyinizi və ya əməliyyatlar göndərməyinizi bloklaya bilməz. Məsələn, Twitter Ethereum-da olsaydı, heç kim hesabınızı bloklaya bilməz və ya tvit yazmağınıza mane ola bilməzdi.", + "page-dapps-features-2-title": "Senzuradan azad", + "page-dapps-features-3-description": "Ethereum-da ETH olduğundan, ödənişlər Ethereum-a aiddir. Tərtibatçıların üçüncü tərəf ödəniş təminatçıları ilə inteqrasiyaya vaxt sərf etmələrinə ehtiyac yoxdur.", + "page-dapps-features-3-title": "Quraşdırılmış ödənişlər", + "page-dapps-features-4-description": "Mərkəzləşdirilməmiş tətbiq kodu açıqdır və standart olaraq uyğundur. Komandalar müntəzəm olaraq digər komandaların işlərindən istifadə edərək qururlar. İstifadəçilərə mərkəzləşdirilməmiş tətbiqdə tokenləri dəyişməyə icazə vermək istəyirsinizsə, sadəcə başqa bir mərkəzləşdirilməmiş tətbiq kodunu daxil edə bilərsiniz.", + "page-dapps-features-4-title": "Qoşmaq və oynamaq", + "page-dapps-features-5-description": "Əksər mərkəzləşdirilməmiş tətbiqlərdə real dünya şəxsiyyətinizi paylaşmağa ehtiyac yoxdur. Ethereum hesabınız sizin girişinizdir və sizə sadəcə pul kisəsi lazımdır.", + "page-dapps-features-5-title": "Bir anonim giriş", + "page-dapps-features-6-description": "Kriptoqrafiya hücumçuların sizin adınıza əməliyyatlar və digər mərkəzləşdirilməmiş tətbiq qarşılıqlı əlaqələrini saxtalaşdıra bilməyəcəyini təmin edir. Ethereum hesabınızla - adətən cüzdanınız vasitəsilə - mərkəzləşdirilməmiş tətbiq hərəkətlərinə icazə verirsiniz ki, etimadnamələriniz təhlükəsiz olsun.", + "page-dapps-features-6-title": "Kriptoqrafiya ilə dəstəklənir", + "page-dapps-features-7-description": "MT Ethereum-da canlı olduqdan sonra, yalnız Ethereum-un özü aşağı düşərsə, enəcək. Ethereum ölçüsündə şəbəkələrə hücum etmək çox çətindir.", + "page-dapps-features-7-title": "Fasilə yoxdur", + "page-dapps-finance-benefits-1-description": "Ethereum-da işləyən maliyyə xidmətlərinin qeydiyyat tələbləri yoxdur. Pulunuz və internet bağlantınız varsa, getməyə hazırsınız.", + "page-dapps-finance-benefits-1-title": "Açıq giriş", + "page-dapps-finance-benefits-2-description": "Bu maliyyə məhsulları ilə qarşılıqlı əlaqə qura biləcəyiniz bütün əlamətlər dünyası var. İnsanlar hər zaman Ethereum-un üstündə yeni tokenlər qururlar.", + "page-dapps-finance-benefits-2-title": "Yeni token iqtisadiyyatı", + "page-dapps-finance-benefits-3-description": "Komandalar stabilkoinlər yaratdılar - daha az dəyişkən kriptovalyuta. Bunlar sizə risk və qeyri-müəyyənlik olmadan kriptovalyutanı sınaqdan keçirməyə və istifadə etməyə imkan verir.", + "page-dapps-finance-benefits-3-title": "Stabil koinlər", + "page-dapps-finance-benefits-4-description": "Ethereum məkanındakı maliyyə məhsulları hamısı moduldur və bir-biri ilə uyğun gəlir. Bu modulların yeni konfiqurasiyaları hər zaman bazara çıxır və kriptovalyutanızla nə edə biləcəyinizi artırır.", + "page-dapps-finance-benefits-4-title": "Bir-biri ilə əlaqəli maliyyə xidmətləri", + "page-dapps-finance-benefits-description": "Mərkəzləşdirilməmiş maliyyə tətbiqlərinin inkişaf etməsinə imkan verən Ethereum haqqında nə var?", + "page-dapps-finance-benefits-title": "mərkəzləşdirilməmiş maliyyə", + "page-dapps-finance-button": "Maliyyə", + "page-dapps-finance-description": "Bunlar kriptovalyutalardan istifadə edərək maliyyə xidmətlərinin yaradılmasına yönəlmiş proqramlardır. Onlar borc vermək, borc götürmək, faiz qazanmaq və şəxsi ödənişlər təklif edirlər - şəxsi məlumat tələb olunmur.", + "page-dapps-finance-title": "Mərkəzləşdirilməmiş maliyyə", + "page-dapps-foundation-logo-alt": "Foundation loqosu", + "page-dapps-gaming-benefits-1-description": "İstər virtual torpaq, istərsə də ticarət kartları olsun, elementləriniz kolleksiya bazarlarında satıla bilər. Oyundaxili elmentləriniz real dünya dəyərinə malikdir.", + "page-dapps-gaming-benefits-1-title": "Oyun elementləri tokenlərin iki qatıdır", + "page-dapps-gaming-benefits-2-description": "Siz əşyalarınıza və bəzi hallarda oyun şirkətlərinə deyil, irəliləyişinizə sahibsiniz. Beləliklə, oyunun arxasında olan şirkət hücuma məruz qaldıqda, server nasazlığı ilə qarşılaşarsa və ya dağılırsa, heç nə itirməyəcəksiniz.", + "page-dapps-gaming-benefits-2-title": "Topladıqlarınız təhlükəsizdir", + "page-dapps-gaming-benefits-3-description": "Eyni şəkildə Ethereum ödənişlərini hər kəs yoxlamaq üçün əlçatandır, oyunlar ədalətliliyi təmin etmək üçün bu keyfiyyətdən istifadə edə bilər. Nəzəri olaraq, kritik vuruşların sayından rəqibin döyüş qabiliyyətinə qədər hər şey yoxlanıla bilər.", + "page-dapps-gaming-benefits-3-title": "Sübut edilə bilən ədalət", + "page-dapps-gaming-benefits-description": "Mərkəzləşdirilməmiş oyunun inkişaf etməsinə imkan verən Ethereum haqqında nə var?", + "page-dapps-gaming-benefits-title": "mərkəzləşdirilməmiş oyun", + "page-dapps-gaming-button": "Oyun", + "page-dapps-gaming-description": "Bunlar virtual dünyaların yaradılmasına və real dünya dəyəri olan kolleksiyalardan istifadə edərək digər oyunçularla mübarizəyə yönəlmiş proqramlardır.", + "page-dapps-gaming-title": "Mərkəzləşdirilməmiş oyun", + "page-dapps-get-some-eth-description": "MT hərəkətləri əməliyyat haqqına başa gəlir", + "page-dapps-get-started-subtitle": "MT-ni sınamaq üçün sizə pulqabı və bir az ETH lazımdır. Pulqabı sizə qoşulmağa və ya daxil olmağa imkan verəcək. İstənilən əməliyyat haqqını ödəmək üçün sizə ETH lazımdır.", + "page-dapps-get-started-title": "Başla", + "page-dapps-gitcoin-grants-logo-alt": "Gitcoin Grants loqosu", + "page-dapps-gitcoin-logo-alt": "Gitcoin loqosu", + "page-dapps-gods-unchained-logo-alt": "Gods Unchained loqosu", + "page-dapps-golem-logo-alt": "Golem loqosu", + "page-dapps-radicle-logo-alt": "Radicle loqosu", + "page-dapps-hero-header": "Ethereum tərəfindən dəstəklənən alətlər və xidmətlər", + "page-dapps-hero-subtitle": "MT biznes modellərini pozmaq və ya yenilərini icad etmək üçün Ethereum-dan istifadə edən tətbiqlərin artan hərəkətidir.", + "page-dapps-how-dapps-work-p1": "MT mərkəzləşdirilmiş serverdə deyil, mərkəzləşdirilməmiş şəbəkədə işləyən backend koduna (ağıllı müqavilələrə) malikdir. Onlar məlumatların saxlanması üçün Ethereum blokçeynindən və tətbiq məntiqi üçün ağıllı müqavilələrdən istifadə edirlər.", + "page-dapps-how-dapps-work-p2": "Ağıllı müqavilə hamının görməsi və tam olaraq bu qaydalara uyğun işləməsi üçün zəncir üzərində yaşayan qaydalar toplusuna bənzəyir. Bir avtomat təsəvvür edin: onu kifayət qədər vəsait və düzgün seçimlə təmin etsəniz, istədiyiniz əşyanı alacaqsınız. Avtomatlar kimi, ağıllı müqavilələr də Ethereum hesabınız kimi vəsait saxlaya bilər. Bu, koda razılaşma və əməliyyatlarda vasitəçilik etməyə imkan verir.", + "page-dapps-how-dapps-work-p3": "MT Ethereum şəbəkəsində yerləşdirildikdən sonra onları dəyişdirə bilməzsiniz. MT mərkəzləşdirilə bilər, çünki onlar fərdi və ya şirkət tərəfindən deyil, müqavilədə yazılmış məntiqlə idarə olunur.", + "page-dapps-how-dapps-work-title": "MT necə işləyir", + "page-dapps-learn-callout-button": "Quraşdır", + "page-dapps-learn-callout-description": "İcma tərtibatçı portalımızda proqram yaratmağa başlamağınıza kömək edəcək sənədlər, alətlər və çərçivələr var.", + "page-dapps-learn-callout-image-alt": "Leqo kərpicdən ETH simvolu quran əlin təsviri.", + "page-dapps-learn-callout-title": "MT qurmağı öyrənin", + "page-dapps-loopring-logo-alt": "Loopring loqosu", + "page-dapps-magic-behind-dapps-description": "MT adi proqramlar kimi görünə bilər. Ancaq pərdə arxasında bəzi xüsusi keyfiyyətlərə malikdirlər, çünki Ethereum-un bütün super güclərini miras alırlar. MT-ləri tətbiqlərdən fərqləndirən budur.", + "page-dapps-magic-behind-dapps-link": "Ethereum-u möhtəşəm edən nədir?", + "page-dapps-magic-behind-dapps-title": "MT-nin arxasındakı sehr", + "page-dapps-magic-title-1": "Sehr", + "page-dapps-magic-title-2": "arxasında", + "page-dapps-magician-img-alt": "Sehrbazların illüstrasiyaları", + "page-dapps-marble-cards-logo-alt": "marble.cards loqosu", + "page-dapps-async-logo-alt": "Async loqosu", + "page-dapps-matcha-logo-alt": "Matcha loqosu", + "page-dapps-mobile-options-header": "Başqa kateqoriyaya baxın", + "page-dapps-nifty-gateway-logo-alt": "Nifty Gateway loqosu", + "page-dapps-oasis-logo-alt": "Oasis loqosu", + "page-dapps-opensea-logo-alt": "OpenSea loqosu", + "page-dapps-opera-logo-alt": "Opera loqosu", + "page-dapps-polymarket-logo-alt": "Polymarket loqosu", + "page-dapps-poap-logo-alt": "Proof of Attendance Protocol loqosu", + "page-dapps-pooltogether-logo-alt": "PoolTogether loqosu", + "page-dapps-rarible-logo-alt": "Rarible loqosu", + "page-dapps-ready-button": "Keç", + "page-dapps-ready-description": "Sınamaq üçün bir MT seçin", + "page-dapps-ready-title": "Hazırsan?", + "page-dapps-sablier-logo-alt": "Sablier loqosu", + "page-dapps-set-up-a-wallet-button": "Pulqabı tap", + "page-dapps-set-up-a-wallet-description": "Pulqabı MT üçün \"girişiniz\"dir", + "page-dapps-set-up-a-wallet-title": "Pulqabı qurun", + "page-dapps-superrare-logo-alt": "SuperRare loqosu", + "page-dapps-technology-button": "Texnologiya", + "page-dapps-technology-description": "Bunlar tərtibatçı alətlərinin mərkəzsizləşdirilməsinə, kripto-iqtisadi sistemlərin mövcud texnologiyaya daxil edilməsinə və açıq mənbəli inkişaf işləri üçün bazarların yaradılmasına yönəlmiş tətbiqlərdir.", + "page-dapps-technology-title": "Mərkəzləşdirilməmiş texnologiya", + "page-dapps-token-sets-logo-alt": "Token Sets loqosu", + "page-dapps-tornado-cash-logo-alt": "Tornado cash loqosu", + "page-dapps-uniswap-logo-alt": "Uniswap loqosu", + "page-dapps-wallet-callout-button": "Pulqabı tap", + "page-dapps-wallet-callout-description": "Pulqabılar da mərkəzləşdirilməmiş tətbiqlərdir. Sizə uyğun olan xüsusiyyətlərə əsasən birini tapın.", + "page-dapps-wallet-callout-image-alt": "Robotun təsviri.", + "page-dapps-wallet-callout-title": "Pulqabılara baxın", + "page-dapps-warning-header": "Həmişə öz araşdırmanızı edin", + "page-dapps-warning-message": "Ethereum yeni texnologiyadır və tətbiqlərin əksəriyyəti yenidir. Hər hansı böyük miqdarda pul yatırmazdan əvvəl riskləri anladığınızdan əmin olun.", + "page-dapps-what-are-dapps": "MT nədir?", + "page-dapps-more-on-defi-button": "Mərkəzləşdirilməmiş maliyyə haqqında daha çox", + "page-dapps-more-on-nft-button": "Tokenləşdirilmiş kolleksiyalar haqqında daha çox", + "page-dapps-more-on-nft-gaming-button": "Tokenləşdirilmiş oyundaxili elementlər haqqında ətraflı", + "page-dapps-dapp-description-pwn": "Ethereum-da hər hansı bir token və ya NFT ilə dəstəklənən asan kreditlər.", + "page-dapps-pwn-image-alt": "PWN loqosu", "foundation": "Fond", "transaction-fees": "Köçürmə üzrə xidmət haqları nə qədərdir?", "page-wallets-get-some": "Bir az ETH alın" diff --git a/src/intl/az/page-stablecoins.json b/src/intl/az/page-stablecoins.json index e17bbbc5ac9..d0f16a64a50 100644 --- a/src/intl/az/page-stablecoins.json +++ b/src/intl/az/page-stablecoins.json @@ -1,4 +1,151 @@ { + "page-stablecoins-accordion-borrow-crypto-collateral": "Kripto girov", + "page-stablecoins-accordion-borrow-crypto-collateral-copy": "Ethereum ilə ETH-nizi satmadan birbaşa digər istifadəçilərdən borc ala bilərsiniz. Bu sizə nüfuz qazandıra bilər – bəziləri bunu daha çox ETH toplamaq üçün edir.", + "page-stablecoins-accordion-borrow-crypto-collateral-copy-p2": "Lakin ETH-nin qiyməti dəyişkən olduğundan, həddindən artıq girov qoymalısınız. Bu o deməkdir ki, 100 stabilkoin borc almaq istəyirsinizsə, yəqin ki, ən azı 150 dollar dəyərində ETH-yə ehtiyacınız olacaq. Bu, sistemi və kreditorları qoruyur.", + "page-stablecoins-accordion-borrow-crypto-collateral-link": "Kripto ilə dəstəklənən stabilkoinlər haqqında ətraflı məlumat", + "page-stablecoins-accordion-borrow-pill": "Advanced", + "page-stablecoins-accordion-borrow-places-intro": "Bu mərkəzləşdirilməmiş tətbiqlər girov kimi kriptovalyutadan istifadə edərək stabilkoinlər götürməyə imkan verir. Bəziləri ETH kimi digər tokenləri də qəbul edir.", + "page-stablecoins-accordion-borrow-places-title": "Stabilkoinləri borc götürmək üçün yerlər", + "page-stablecoins-accordion-borrow-requirement-1": "Ethereum pulqabısı", + "page-stablecoins-accordion-borrow-requirement-1-description": "MT-dən istifadə etmək üçün sizə pulqabı lazımdır", + "page-stablecoins-accordion-borrow-requirement-2": "Ether (ETH)", + "page-stablecoins-accordion-borrow-requirement-2-description": "Girov və/və ya əməliyyat haqları üçün sizə ETH lazımdır", + "page-stablecoins-accordion-borrow-requirements-description": "Stabilkoinləri borc almaq üçün düzgün mərkəzləşdirilməmiş tətbiqlərdən istifadə etməlisiniz. Sizə həmçinin pulqabı və ETH lazımdır.", + "page-stablecoins-accordion-borrow-risks-copy": "ETH-ni girov kimi istifadə etsəniz və onun dəyəri aşağı düşərsə, girovunuz yaratdığınız stabilkoinləri əhatə etməyəcək. Bu, ETH-nin ləğv edilməsinə səbəb olacaq və siz cəza ilə üzləşə bilərsiniz. Ona görə də, stabilkoinlər götürsəniz, ETH qiymətini izləməlisiniz.", + "page-stablecoins-accordion-borrow-risks-link": "Ən son ETH qiyməti", + "page-stablecoins-accordion-borrow-risks-title": "Risklər", + "page-stablecoins-accordion-borrow-text-preview": "Siz geri ödəməli olduğunuz kriptovalyutanı girov olaraq istifadə edərək bəzi stabilkoinlər götürə bilərsiniz.", + "page-stablecoins-accordion-borrow-title": "Borc almaq", + "page-stablecoins-accordion-buy-exchanges-title": "Populyar valyuta", + "page-stablecoins-accordion-buy-requirement-1": "Kriptovalyutalar və pulqabılar", + "page-stablecoins-accordion-buy-requirement-1-description": "Yaşadığınız yerdə istifadə edə biləcəyiniz xidmətləri yoxlayın", + "page-stablecoins-accordion-buy-requirements-description": "Birbaşa kripto ala biləcəyiniz valyuta və ya pulqabı olan hesab. ETH əldə etmək üçün artıq birindən istifadə etmisiniz. Yaşadığınız yerdə hansı xidmətlərdən istifadə edə biləcəyinizi yoxlayın.", + "page-stablecoins-accordion-buy-text-preview": "Bir çox valyuta və pulqabı birbaşa stabilkoinlər almağa imkan verir. Coğrafi məhdudiyyətlər tətbiq olunacaq.", + "page-stablecoins-accordion-buy-title": "Almaq", + "page-stablecoins-accordion-buy-warning": "Mərkəzləşdirilmiş birjalar yalnız USDC, Tether və digərləri kimi qanunla dəstəklənən stabilkoinləri siyahıya sala bilər. Onları birbaşa ala bilməyəcəksiniz, lakin ETH və ya platformada ala biləcəyiniz digər kriptovalyutalardan mübadilə edə bilməlisiniz.", + "page-stablecoins-accordion-earn-project-1-description": "Əsasən açıq mənbəli proqram təminatı hərəkatı üçün texniki iş.", + "page-stablecoins-accordion-earn-project-2-description": "MakerDao icması (sizə Dai gətirən komanda) üçün texnologiya, məzmun və digər işlər.", + "page-stablecoins-accordion-earn-project-3-description": "Həqiqətən səhvləri necə tapacağınızı bildiyiniz zaman Dai qazana bilərsiniz.", + "page-stablecoins-accordion-earn-project-bounties": "Gitcoin mükafatları", + "page-stablecoins-accordion-earn-project-bug-bounties": "Konsensus qatının səhv mükafatları", + "page-stablecoins-accordion-earn-project-community": "MakerDao icması", + "page-stablecoins-accordion-earn-projects-copy": "Bunlar işiniz üçün sizə stabilkoinlərlə ödəniş edəcək platformalardır.", + "page-stablecoins-accordion-earn-projects-title": "Stabilkoinləri haradan qazanmaq olar", + "page-stablecoins-accordion-earn-requirement-1": "Ethereum pulqabısı", + "page-stablecoins-accordion-earn-requirement-1-description": "Qazandığınız stabilkoinləri almaq üçün sizə pulqabı lazımdır", + "page-stablecoins-accordion-earn-requirements-description": "Dəyəri sabit olduğuna görə stabilkoinlər iş və xidmətlər üçün əla ödəniş üsuludur. Ancaq ödəniş etmək üçün pulqabı lazımdır.", + "page-stablecoins-accordion-earn-text-preview": "Ethereum ekosistemi daxilində layihələr üzərində işləyərək stabilkoinlər qazana bilərsiniz.", + "page-stablecoins-accordion-earn-title": "Qazanmaq", + "page-stablecoins-accordion-less": "Daha az", + "page-stablecoins-accordion-more": "Daha çox", + "page-stablecoins-accordion-requirements": "Nə lazım olacaq", + "page-stablecoins-accordion-swap-dapp-intro": "Əgər sizdə artıq ETH və pulqabı varsa, stabilkoinlərlə dəyişmək üçün bu mərkəzləşdirilməmiş tətbiqlərdən istifadə edə bilərsiniz.", + "page-stablecoins-accordion-swap-dapp-link": "Mərkəzləşdirilməmiş birjalar haqqında ətraflı məlumat", + "page-stablecoins-accordion-swap-dapp-title": "Tokenl dəyişmək üçün mərkəzləşdirilməmiş tətbiqlər", + "page-stablecoins-accordion-swap-editors-tip": "Redaktorların məsləhəti", + "page-stablecoins-accordion-swap-editors-tip-button": "Pulqabı tap", + "page-stablecoins-accordion-swap-editors-tip-copy": "Özünüzə ETH almağa və onu birbaşa stabilkoinlər də daxil olmaqla tokenlərə dəyişdirməyə imkan verən pulqabı əldə edin.", + "page-stablecoins-accordion-swap-pill": "Tövsiyyə edilən", + "page-stablecoins-accordion-swap-requirement-1": "Ethereum pulqabısı", + "page-stablecoins-accordion-swap-requirement-1-description": "Mübadilə etməyə icazə vermək və tokenlərinizi saxlamaq üçün sizə pulqabı lazımdır", + "page-stablecoins-accordion-swap-requirement-2": "Ether (ETH)", + "page-stablecoins-accordion-swap-requirement-2-description": "Mübadilə üçün ödəniş etmək", + "page-stablecoins-accordion-swap-text-preview": "Əksər stabilkoinləri mərkəzləşdirilməmiş birjalarda ala bilərsiniz. Beləliklə, əldə edə biləcəyiniz hər hansı bir tokeni istədiyiniz stabilkoin ilə dəyişə bilərsiniz.", + "page-stablecoins-accordion-swap-title": "Mübadilə", + "page-stablecoins-algorithmic": "Alqoritmik", + "page-stablecoins-algorithmic-con-1": "Siz alqoritmə etibar etməlisiniz (yaxud oxuya bilməlisiniz).", + "page-stablecoins-algorithmic-con-2": "Token balansınız ümumi tədarük əsasında dəyişəcək.", + "page-stablecoins-algorithmic-description": "Bu stabilkoinlər heç bir başqa aktiv tərəfindən dəstəklənmir. Əvəzində alqoritm qiymət istənilən dəyərdən aşağı düşərsə, tokenləri satacaq və dəyər istənilən məbləği keçərsə, tokenləri tədarük edəcək. Dövriyyədə olan bu tokenlərin sayı müntəzəm olaraq dəyişdiyinə görə, sahib olduğunuz tokenlərin sayı dəyişəcək, lakin həmişə sizin payınızı əks etdirəcək.", + "page-stablecoins-algorithmic-pro-1": "Girov tələb olunmur.", + "page-stablecoins-algorithmic-pro-2": "İctimai alqoritmlə idarə olunur.", + "page-stablecoins-bank-apy": "0,05%", + "page-stablecoins-bank-apy-source": "Banklar tərəfindən ABŞ-ın Federal sığortalı əsas əmanət hesabları üzrə ödənilən orta dərəcə.", + "page-stablecoins-bank-apy-source-link": "Mənbə", + "page-stablecoins-bitcoin-pizza": "Məşhur Bitcoin pizzası", + "page-stablecoins-bitcoin-pizza-body": "2010-cu ildə kimsə 10 000 bitkoinə 2 pizza alıb. O zaman bunlar ~41 ABŞ dolları dəyərində idi. İndiki bazarda bu milyonlarla dollardır. Ethereum tarixində bir çox oxşar təəssüf doğuran əməliyyatlar var. Stabilkoinlər bu problemi həll edir, beləliklə siz pizzanızdan həzz ala və ETH-ni saxlaya biləsiniz.", + "page-stablecoins-coin-price-change": "Token qiymət dəyişikliyi (son 30 gün)", + "page-stablecoins-crypto-backed": "Kripto ilə dəstəklənən", + "page-stablecoins-crypto-backed-con-1": "Fiat dəstəkli stabilkoinlərdən daha az stabildir.", + "page-stablecoins-crypto-backed-con-2": "Kripto girovun dəyərinə diqqət yetirməlisiniz.", + "page-stablecoins-crypto-backed-description": "Bu stabilkoinlər ETH kimi digər kriptovalyutalar tərəfindən dəstəklənir. Onların qiyməti dəyişkən ola bilən əsas aktivin (və ya girovun) dəyərindən asılıdır. ETH-nin dəyəri dəyişə bildiyindən, qiymətin mümkün qədər sabit qalmasını təmin etmək üçün bu stabilkoinlər həddindən artıq təmin edilir. Bu o deməkdir ki, 1 dollarlıq kriptovalyuta ilə dəstəklənən stabilkoinin ən azı 2 dollar dəyərində əsas kriptovalyutası olduğunu söyləmək daha yaxındır. Beləliklə, ETH-nin qiyməti düşərsə, stabilkoini dəstəkləmək üçün daha çox ETH istifadə edilməlidir, əks halda stabilkoinlər öz dəyərini itirəcək.", + "page-stablecoins-crypto-backed-pro-1": "Şəffaf və tam mərkəzləşdirilməmiş.", + "page-stablecoins-crypto-backed-pro-2": "Digər kripto aktivlərə tez çevrilir.", + "page-stablecoins-crypto-backed-pro-3": "Xarici qəyyumlar yoxdur – bütün aktivlər Ethereum hesabları tərəfindən idarə olunur.", + "page-stablecoins-dai-banner-body": "Dai, ehtimal ki, ən məşhur mərkəzləşdirilməmiş stabilkoindir. Onun dəyəri təqribən bir dollardır və bütün mərkəzləşdirilməmiş tətbiqlər tərəfindən qəbul edilir.", + "page-stablecoins-dai-banner-learn-button": "Dai haqqında məlumat əldə edin", + "page-stablecoins-dai-banner-swap-button": "ETH-ni Dai ilə dəyişdirin", + "page-stablecoins-dai-banner-title": "Dai", + "page-stablecoins-dai-logo": "Dai loqosu", + "page-stablecoins-editors-choice": "Redaktorların seçimləri", + "page-stablecoins-editors-choice-intro": "Bunlar yəqin ki, hazırda stabilkoinlərin ən məşhur nümunələri və MT istifadə edərkən faydalı olduğunu düşündüyümüz tokenlərdir.", + "page-stablecoins-explore-dapps": "MT-ni araşdırın", + "page-stablecoins-fiat-backed": "Fiat ilə dəstəklənən", + "page-stablecoins-fiat-backed-con-1": "Mərkəzləşdirilmiş – tokenləri kimsə idarə edir.", + "page-stablecoins-fiat-backed-con-2": "Şirkətin kifayət qədər ehtiyata malik olmasını təmin etmək üçün audit tələb olunur.", + "page-stablecoins-fiat-backed-description": "Əsasən ənənəvi fiat valyutası (adətən dollar) üçün bir IOU (sizə borcluyam). Siz sonradan nağdlaşdıra və orijinal valyutanız üçün geri ala biləcəyiniz stabilkoin almaq üçün fiat valyutanızdan istifadə edirsiniz.", + "page-stablecoins-fiat-backed-pro-1": "Kripto dəyişkənliyinə qarşı təhlükəsizdir.", + "page-stablecoins-fiat-backed-pro-2": "Qiymətdə dəyişikliklər minimaldır.", + "page-stablecoins-find-stablecoin": "Stabilkoin tapın", + "page-stablecoins-find-stablecoin-how-to-get-them": "Stabilkoinləri necə əldə etmək olar", + "page-stablecoins-find-stablecoin-intro": "Yüzlərlə stabilkoin mövcuddur. Başlamağınıza kömək edəcək bəzi şeylər bunlardır. Ethereum-da yenisinizsə, əvvəlcə bir az araşdırma etməyi məsləhət görürük.", + "page-stablecoins-find-stablecoin-types-link": "Müxtəlif stabilkoin növləri", + "page-stablecoins-get-stablecoins": "Stabilkoinləri necə əldə etmək olar", + "page-stablecoins-hero-alt": "Bazar dəyərinə görə üç ən böyük stabilkoin: Dai, USDC və Tether.", + "page-stablecoins-hero-button": "Stabilkoinlər əldə et", + "page-stablecoins-hero-header": "Gündəlik istifadə üçün rəqəmsal pul", + "page-stablecoins-hero-subtitle": "Stabilkoinlər, hətta ETH qiyməti dəyişdikdə belə sabit bir dəyərdə qalmaq üçün nəzərdə tutulmuş Ethereum tokenləridir.", + "page-stablecoins-interest-earning-dapps": "Faiz qazandıran MT", + "page-stablecoins-meta-description": "Ethereum stabilkoinləri ilə tanışlıq: onlar nədir, onları necə əldə etmək olar və nə üçün vacibdirlər.", + "page-stablecoins-precious-metals": "Qiymətli metallar", + "page-stablecoins-precious-metals-con-1": "Mərkəzləşdirilmiş – tokenləri kimsə idarə edir.", + "page-stablecoins-precious-metals-con-2": "Token emitentinə və qiymətli metal ehtiyatlarına etibar etməlisiniz.", + "page-stablecoins-precious-metals-description": "Fiat dəstəkli tokenlər kimi, əvəzinə bu stabilkoinlər öz dəyərini qorumaq üçün qızıl kimi resurslardan istifadə edirlər.", + "page-stablecoins-precious-metals-pro-1": "Kripto dəyişkənliyinə qarşı təhlükəsizdir.", + "page-stablecoins-prices": "Stabilkoin qiymətləri", + "page-stablecoins-prices-definition": "Stabilkoinlər dəyişkənliyi olmayan kriptovalyutalardır. Onlar ETH ilə eyni gücləri paylaşırlar, lakin onların dəyəri sabitdir, daha çox ənənəvi valyutaya bənzəyir. Beləliklə, Ethereum-da istifadə edə biləcəyiniz sabit pula çıxışınız var. ", + "page-stablecoins-prices-definition-how": "Stabilkoinlər sabitliyini necə əldə edir", + "page-stablecoins-research-warning": "Ethereum yeni texnologiyadır və tətbiqlərin əksəriyyəti yenidir. Riskdən xəbərdar olduğunuzdan əmin olun və yalnız itirə biləcəyinizi əmanət edin.", + "page-stablecoins-research-warning-title": "Həmişə öz araşdırmanızı edin", + "page-stablecoins-save-stablecoins": "Stabilkoinlərlə qənaət edin", + "page-stablecoins-save-stablecoins-body": "Stabilkoinlər, adətən, ortalamadan yuxarı depozit faiz dərəcəsinə malikdirlər, çünki onları borc almaq üçün çoxlu tələb var. Stabilkoinləri kredit tətbiqlərində yerləşdirməklə real vaxt rejimində faiz qazanmağa imkan verən dapp-lar var. Bank dünyasında olduğu kimi, siz borcalanlar üçün tokenlər təqdim edirsiniz, lakin istədiyiniz zaman tokenlərinizi və faizlərinizi geri ala bilərsiniz.", + "page-stablecoins-saving": "Stabilkoin əmanətlərinizi yaxşı istifadə edin və bir qədər faiz qazanın. Kriptovalyutada hər şey kimi, proqnozlaşdırılan İllik Faiz Gəlirləri (APY) real vaxt rejimində tələb/təklifdən asılı olaraq gündəlik dəyişə bilər.", + "page-stablecoins-stablecoins-dapp-callout-description": "Ethereum-un mərkəzləşdirilməmiş tətbiqlərinə baxın – stabilkoinlər, adətən, gündəlik əməliyyatlar üçün daha faydalıdır.", + "page-stablecoins-stablecoins-dapp-callout-image-alt": "Doge təsviri.", + "page-stablecoins-stablecoins-dapp-callout-title": "Stabilkoinlərinizi istifadə etmək", + "page-stablecoins-stablecoins-dapp-description-1": "Dai, USDC, TUSD, USDT və s. daxil olmaqla bir çox stabilkoin üçün bazarlar.", + "page-stablecoins-stablecoins-dapp-description-2": "Stabilkoinlər verin və faiz və Compound-un öz tokeni olan $COMP qazanın.", + "page-stablecoins-stablecoins-dapp-description-3": "Dai və USDC-də faiz qazana biləcəyiniz ticarət platforması.", + "page-stablecoins-stablecoins-dapp-description-4": "Dai-yə qənaət etmək üçün nəzərdə tutulmuş proqram.", + "page-stablecoins-stablecoins-feature-1": "Stabilkoinlər qlobaldır və internet vasitəsilə göndərilə bilər. Ethereum hesabınız olduqdan sonra onları qəbul etmək və ya göndərmək asandır.", + "page-stablecoins-stablecoins-feature-2": "Stabilkoinlərə tələbat yüksəkdir, ona görə də öz borcunuzu vermək üçün faiz qazana bilərsiniz. Kredit verməzdən əvvəl risklərdən xəbərdar olduğunuzdan əmin olun.", + "page-stablecoins-stablecoins-feature-3": "Stabilkoinlər ETH və digər Ethereum tokenləri ilə dəyişdirilə bilər. Bir çox mərkəzləşdirilməmiş tətbiqlər stabilkoinlərə güvənir.", + "page-stablecoins-stablecoins-feature-4": "Stabilkoinlər kriptoqrafiya ilə qorunur. Heç kim sizin adınıza saxta əməliyyatlar edə bilməz.", + "page-stablecoins-stablecoins-meta-description": "Ethereum stabilkoinləri ilə tanışlıq: onlar nədir, onları necə əldə etmək olar və nə üçün vacibdirlər.", + "page-stablecoins-stablecoins-table-header-column-1": "Valyuta", + "page-stablecoins-stablecoins-table-header-column-2": "Bazar kapitallaşması", + "page-stablecoins-stablecoins-table-header-column-3": "Girov növü", + "page-stablecoins-stablecoins-table-type-crypto-backed": "Kripto", + "page-stablecoins-stablecoins-table-type-fiat-backed": "Fiat", + "page-stablecoins-stablecoins-table-type-precious-metals-backed": "Qiymətli metallar", + "page-stablecoins-table-error": "Stabilkoinləri yükləmək mümkün olmadı. Səhifəni yeniləməyə çalışın.", + "page-stablecoins-table-loading": "Stabilkoin datası yüklənir...", + "page-stablecoins-title": "Stabilkoinlər", + "page-stablecoins-top-coins": "Bazar kapitallaşmasına görə ən yaxşı stabilkoinlər", + "page-stablecoins-top-coins-intro": "Bazar kapitallaşması:", + "page-stablecoins-top-coins-intro-code": "mövcud tokenlərin ümumi sayı tokenə düşən dəyərə vurulur. Bu siyahı dinamikdir və burada sadalanan layihələr mütləq ethereum.org komandası tərəfindən təsdiqlənmir.", + "page-stablecoins-types-of-stablecoin": "Necə işləyirlər: stabilkoin növləri", + "page-stablecoins-usdc-banner-body": "USDC, ehtimal ki, ən məşhur fiat dəstəkli stabilkoindir. Onun dəyəri təxminən bir dollardır və Circle və Coinbase tərəfindən dəstəklənir.", + "page-stablecoins-usdc-banner-learn-button": "USDC haqqında məlumat əldə edin", + "page-stablecoins-usdc-banner-swap-button": "ETH-ni USDC ilə dəyişdirin", + "page-stablecoins-usdc-banner-title": "USDC", + "page-stablecoins-usdc-logo": "USDC loqosu", + "page-stablecoins-why-stablecoins": "Niyə stabilkoinlər?", + "page-stablecoins-how-they-work-button": "Necə işləyirlər", + "page-stablecoins-why-stablecoins-body": "ETH Bitcoin kimi yeni texnologiya olduğu üçün dəyişkən bir qiymətə malikdir. Buna görə də müntəzəm olaraq xərcləmək istəməyə bilərsiniz. Stabilkoinlər, Ethereum-da istifadə edə biləcəyiniz sabit pula çıxış imkanı vermək üçün ənənəvi valyutaların dəyərini əks etdirir.", + "page-stablecoins-more-defi-button": "Mərkəzləşdirilməmiş maliyyə (DeFi) haqqında daha çox məlumat", + "page-stablecoins-tools-title": "Stabilkoinlər haqqında daha çox məlumat əldə edin", + "page-stablecoins-tools-stablecoinswtf-description": "Stablecoins.wtf ən görkəmli stabilkoinlər üçün tarixi bazar məlumatları, statistika və təhsil məzmunu ilə tablosunu təklif edir.", + "page-dapps-ready-button": "Keç", "pros": "Müsbət cəhətləri", "cons": "Mənfi cəhətləri", "1inch-logo": "1inch loqosu", @@ -7,13 +154,13 @@ "bittrex-logo": "Bittrex loqosu", "coinbase-logo": "Coinbase loqosu", "coinmama-logo": "Coinmama loqosu", - "compound-logo": "Mürəkkəb loqo", + "compound-logo": "Compound loqosu", "example-projects": "Nümunə layihələr", "gemini-logo": "Gemini loqosu", "gitcoin-logo": "Gitcoin loqosu", - "loopring-logo": "Loopring logosu", + "loopring-logo": "Loopring loqosu", "makerdao-logo": "MakerDao loqosu", "matcha-logo": "Matcha loqosu", - "oasis-logo": "Oazis loqosu", + "oasis-logo": "Oasis loqosu", "uniswap-logo": "Uniswap loqosu" } diff --git a/src/intl/az/template-usecase.json b/src/intl/az/template-usecase.json new file mode 100644 index 00000000000..4c12ee2cbeb --- /dev/null +++ b/src/intl/az/template-usecase.json @@ -0,0 +1,11 @@ +{ + "template-usecase-dropdown-defi": "Mərkəzləşdirilməmiş maliyyə (DeFi)", + "template-usecase-dropdown-nft": "Bir-birini əvəz edə bilməyən nişanlar (NFTs)", + "template-usecase-dropdown-dao": "Mərkəzləşdirilməmiş muxtar təşkilatlar (DAO)", + "template-usecase-dropdown-social-networks": "Mərkəzləşdirilməmiş sosial şəbəkələr", + "template-usecase-dropdown-identity": "Mərkəzləşdirilməmiş şəxsiyyət", + "template-usecase-dropdown": "Ethereum-dan istifadə halları", + "template-usecase-banner": "Ethereum-un istifadəsi daim inkişaf və təkamül edir. Hər şeyi daha aydın və ya daha aktual edəcək hər hansı məlumatı əlavə edin.", + "template-usecase-edit-link": "Səhifəni redaktə et", + "template-usecase-dropdown-aria": "Açılan iş menyusundan istifadə edin" +} diff --git a/src/intl/bg/common.json b/src/intl/bg/common.json index bcdf2015710..d576fc635c0 100644 --- a/src/intl/bg/common.json +++ b/src/intl/bg/common.json @@ -1,4 +1,5 @@ { + "account-abstraction": "Абстракция на акаунта", "about-ethereum-org": "За ethereum.org", "about-us": "За нас", "aria-toggle-search-button": "Бутон за търсенеToggle", @@ -6,24 +7,46 @@ "zen-mode": "Дзен режим", "beacon-chain": "Сигнална верига", "bridges": "Мостове на блокова верига", + "clear": "Изчистване", + "close": "Затваряне", "community": "Общност", "community-hub": "Център на общността", "community-menu": "Меню на общността", "contact": "За контакти", + "content-standardization": "Стандартизация на съдържанието", "contributing": "С принос", "contributors": "Сътрудници", "contributors-thanks": "На всеки, който има принос към тази страница – благодаря!", "cookie-policy": "Политика за бисквитките", "copied": "Копирано", "copy": "Копиране", + "danksharding": "Danksharding", "dark-mode": "Тъмно", "data-provided-by": "Източник на данни:", "decentralized-applications-dapps": "Децентрализирани приложения (dapps)", + "decentralized-science": "Децентрализирана наука (DeSci)", "devcon": "Девкон/Devcon", "developers": "Разработчици", "developers-home": "Начална страница на разработчиците", "docs": "Документи", + "docsearch-to-select": "За избор", + "docsearch-to-navigate": "За навигация", + "docsearch-to-close": "За затваряне", + "docsearch-search-by": "Търсене по", + "docsearch-start-recent-searches-title": "Скорошни", + "docsearch-start-no-recent-searches": "Няма скорошни търсения", + "docsearch-start-save-recent-search": "Запазване на търсенето", + "docsearch-start-remove-recent-search": "Премахване на това търсене от хронологията", + "docsearch-start-favorite-searches": "Любими", + "docsearch-start-remove-favorite-search": "Премахване на това търсене от „Любими“", + "docsearch-no-results-text": "Няма резултати за", + "docsearch-no-results-suggested-query": "Опитайте с търсене на", + "docsearch-no-results-missing": "Смятате ли, че това запитване трябва да даде резултати?", + "docsearch-no-results-missing-link": "Кажете ни.", + "docsearch-error-title": "Не могат да се изведат резултати", + "docsearch-error-help": "Проверете връзката си с интернет.", "documentation": "Документация", + "down": "Надолу", "ecosystem": "Екосистема", "edit-page": "Редактиране на страницата", "ef-blog": "Блог на фондация Етереум", @@ -33,9 +56,10 @@ "enterprise-menu": "Меню на предприятието", "esp": "Програма за поддръжка на екосистемата", "eth-current-price": "Настояща цена на ETH (в USD)", + "ethereum-bug-bounty": "Кампания за търсене на бъгове на Етереум", "consensus-when-shipping": "Кога излиза?", "ethereum-upgrades": "Подобрения на Етереум", - "ethereum-brand-assets": "Активи на марката Ethereum", + "ethereum-brand-assets": "Характеристики на марката Етереум", "ethereum-online": "Общности в мрежата", "ethereum-events": "Събития на Етериум", "ethereum-foundation": "Фондация Етереум", @@ -45,18 +69,34 @@ "ethereum-logo": "Лого на Етереум", "ethereum-security": "Сигурност и защита от измами при Ethereum", "ethereum-support": "Поддръжка на Етериум", - "ethereum-wallets": "Портфейлите на Ethereum", + "ethereum-wallets": "Портфейлите на Етереум", "ethereum-whitepaper": "Визията/Принципите/Whitepaper на Етереум", + "feedback-widget-prompt": "Полезна ли е тази страница?", + "feedback-card-prompt-page": "Полезна ли бе тази страница?", + "feedback-card-prompt-article": "Полезна ли бе тази статия?", + "feedback-card-prompt-tutorial": "Полезено ли беше това обучение?", + "feedback-widget-thank-you-title": "Благодарим за обратната връзка!", + "feedback-widget-thank-you-subtitle": "Помогнете да направим тази страница по-добра, като отговорите на няколко въпроса.", + "feedback-widget-thank-you-subtitle-ext": "При нужда от помощ, свържете се с общността в нашия Дискорд.", + "feedback-widget-thank-you-timing": "2 – 3 мин", + "feedback-widget-thank-you-cta": "Започнете кратка анкета", "find-wallet": "Намери портфейл", + "future-proofing": "Подсигуряване за бъдещето", "get-eth": "Вземете ETH", "get-involved": "Включете се", "get-started": "Започнете", "grants": "Дарения", "grant-programs": "Програми за дарения в екосистемата", - "guides-and-resources": "Указатели и източници в общността", + "guides": "Ръководства", + "guides-hub": "Център с ръководства", "history-of-ethereum": "Историята на Етереум", "home": "Начална страница", "how-ethereum-works": "Как работи Етериум", + "how-to-register-an-ethereum-account": "Как да „регистрирате“ акаунт в Етереум", + "how-to-revoke-token-access": "Как да отмените достъпа на интелигентен договор до средствата ви в криптовалута", + "how-to-swap-tokens": "Как да заменяте токени", + "how-to-use-a-bridge": "Как да прехвърляте токени на слой 2", + "how-to-use-a-wallet": "Как се използва портфейл", "image": "изображение", "in-this-section": "В този раздел", "individuals": "Индивидуални потребители", @@ -70,6 +110,7 @@ "layer-2": "Слой 2", "learn": "Научете", "learn-by-coding": "Научете, като кодирате", + "learn-hub": "Обучителен център", "learn-menu": "Как да научиш", "learn-more": "Научи повече", "less": "По-малко", @@ -84,24 +125,33 @@ "nav-developers": "Разработчици", "nav-developers-docs": "Документация за разработчици", "nav-primary": "Основен", + "nfts": "NFT", "no": "Не", "on-this-page": "На тази страница", + "open-research": "Отворено проучване", "page-last-updated": "Последна актуализация на страницата", + "pbs": "Разделяне на предлагащ и строител", "privacy-policy": "Политика за поверителност", "private-ethereum": "Поверителният Етереум", "refresh": "Моля, обновете страницата.", "return-home": "към началната страница", + "roadmap": "Пътна карта на Етереум", "run-a-node": "Активиране на възел", "rollup-component-website": "Уебсайт", "rollup-component-developer-docs": "Документация на разработчика", "rollup-component-technology-and-risk-summary": "Технология и обобщение на рисковете", + "scaling": "Увеличаване на мащаба", "search": "Търсене", + "search-ethereum-org": "Търсене на ethereum.org", + "secret-leader-election": "Таен избор на лидер", "search-box-blank-state-text": "Търсете по-нататък!", "search-eth-address": "Това прилича на адреса на Етереум. Ние не предлагаме данни, които са специфични за даден адрес. Опитайте да го намерите в block explorer като", "search-no-results": "Няма резултати от търсенето ви", + "single-slot-finality": "Финализиране в рамките на един слот", + "statelessness": "Без състояние", "see-contributors": "Вижте сътрудниците", "set-up-local-env": "Настройване на локалната среда", - "sharding": "Вериги от компоненти", + "sharding": "Фрагментиране", "show-all": "Покажи всички", "show-less": "Покажи по-малко", "site-description": "Етереум е глобална, децентрализирана платформа за пари и нови видове приложения. Върху Етереум може да създавате код, който контролира пари, и да правите приложения, достъпни по целия свят.", @@ -109,10 +159,13 @@ "skip-to-main-content": "Прeскачане към основното съдържание", "smart-contracts": "Умни договори", "stablecoins": "Стейбълкойни/Stablecoins", + "stake-eth": "Залагайте ETH", "staking": "Залагане", + "style-guide": "Style guide", "solo": "Самостоятелно залагане", "saas": "Залагането като услуга", "pools": "Групово залагане", + "withdrawals": "Тегления на залози", "terms-of-use": "Условия за ползване", "translation-banner-body-new": "Виждате тази страница на английски език, защото все още не сме я превели. Помогнете ни да преведем съдържанието.", "translation-banner-body-update": "Има нова версия на тази страница, но все още е само на английски език. Помогнете ни да преведем последната версия.", @@ -125,18 +178,26 @@ "translation-banner-no-bugs-dont-show-again": "Да не се показва отново", "try-using-search": "Опитайте да намерите това, което търсите, с търсачката или", "tutorials": "Ръководства", + "up": "Нагоре", "use-ethereum": "Използвайте Етереум", "use-ethereum-menu": "Използвайте менюто на Етереум", + "user-experience": "User experience", + "verkle-trees": "Дърво на Verkle", "wallets": "Портфейли", "we-couldnt-find-that-page": "Не можахме да намерим тази страница", "web3": "Какво представлява Web3?", + "web3-title": "Web3", "website-last-updated": "Последно обновяване на уебсайта", "what-is-ether": "Какво е етер/ether (ETH)?", "what-is-ethereum": "Какво е Етереум?", "defi-page": "Децентрализирани финанси (DeFi)", "dao-page": "Децентрализирани автономни организации (DAOs)", "nft-page": "Незаменяеми токени (NFTs)", + "decentralized-social-networks": "Децентрализирани социални мрежи", + "decentralized-identity": "Децентрализирана самоличност", "yes": "Да", + "zero-knowledge-proofs": "Доказателства за нулево знание", + "ethereum-roadmap": "Пътна карта на Етереум", "page-index-meta-title": "Начална страница", - "page-developers-aria-label": "Меню на разработчиците" + "page-developers-aria-label": "Developers' Menu" } diff --git a/src/intl/bg/page-eth.json b/src/intl/bg/page-eth.json index 03a4ed59f24..5d974fdfa9e 100644 --- a/src/intl/bg/page-eth.json +++ b/src/intl/bg/page-eth.json @@ -13,14 +13,14 @@ "page-eth-flexible-amounts": "В наличност е в гъвкави количества", "page-eth-flexible-amounts-desc": "ETH се разделя до 18 десетични знака, така че не е необходимо да купувате 1 цял ETH. Може в даден момент да купите частици от него – даже само 0.000000000000000001 ETH, ако желаете.", "page-eth-fuels": "ETH зарежда и подсигурява Етереум", - "page-eth-fuels-desc": "ETH е кръвта в живота на Етереум. Когато изпращате ETH или ползвате дадено Етереум приложение, вие плащате малка такса в ETH, за да използвате мрежата на Етереум. Тази такса е стимул за копачите да придвижат и верифицират това, което се опитвате да направите.", - "page-eth-fuels-desc-2": "Копачите са като контролни органи на Етереум – те проверяват и доказват, че никой не мами. Копачите, които вършат тази работа, сащо биват възнаградени с малки количества от новосъздадения ETH.", - "page-eth-fuels-desc-3": "Копачите правят Етереум сигурен и свободен от централизирания контрол. С други думи,", - "page-eth-fuels-staking": "ETH ще стане още по-важен със залагането. Когато залагате вашите ETH, ще може да допринесете за сигурността на Етереум и да спечелите награди. В тази система опасността от загуба на вашите ETH обезсърчава атаките.", + "page-eth-fuels-desc": "ETH е поддържащата сила на Етереум. Когато изпращате ETH или използвате дадено приложение в Етереум, вие плащате такса в ETH, за да използвате мрежата на Етереум. Тази такса е стимул за създателите на блокове да обработват и проверяват това, което се опитвате да направите.", + "page-eth-fuels-desc-2": "Валидаторите са нещо като завеждащи протоколите на Етереум – те проверяват и доказват, че никой не мами. Те се избират на произволен принцип за обработката на блок с трансакции. Валидаторите, които вършат тази работа, също така малко количество новоиздаден ETH като възнаграждение.", + "page-eth-fuels-desc-3": "Работата, която вършат валидаторите, и заложеният от тях капитал правят Етереум сигурна и свободна от централизиран контрол мрежа.", + "page-eth-fuels-staking": "Когато залагате вашия ETH, вие помагате за осигуряването на Етереум и печелите награди. В тази система страхът от загуба на ETH възпира хакерите.", "page-eth-fuels-more-staking": "Повече за залагането", "page-eth-get-eth-btn": "Вземете ETH", "page-eth-gov-tokens": "Управленски токени", - "page-eth-gov-tokens-desc": "Токени, които представляват възможността за гласуване в децентрализираните организации.", + "page-eth-gov-tokens-desc": "Токени, които представляват възможност за гласуване в децентрализираните организации.", "page-eth-has-value": "Защо ETH има стойност?", "page-eth-has-value-desc": "ETH е ценен по различен начин за различните хора.", "page-eth-has-value-desc-2": "За потребителите на Етереум ETH е ценен, защото ви позволява да плащате таксите по трансакциите.", @@ -84,10 +84,11 @@ "page-eth-tokens-defi": "Децентрализирани финанси (DeFi)", "page-eth-tokens-nft": "Незаменяеми токени (NFTs)", "page-eth-tokens-dao": "Децентрализирани автономни организации (DAOs)", - "page-eth-tokens-stablecoins-description": "Повече за най-малко променливия токен на Етереум.", - "page-eth-tokens-defi-description": "Финансовата система на токените на Етереум.", - "page-eth-tokens-nft-description": "Токени, които представляват правото на собственост върху дадени неща в Етереум.", + "page-eth-tokens-stablecoins-description": "Повече за най-малко променливия токен на Ethereum.", + "page-eth-tokens-defi-description": "Финансовата система на токените на Ethereum.", + "page-eth-tokens-nft-description": "Токени, които представляват правото на собственост върху дадени неща в Ethereum.", "page-eth-tokens-dao-description": "Интернет общностите често се управляват от притежателите на токени.", "page-eth-whats-defi": "Повече за DeFi", - "page-eth-whats-defi-description": "DeFi е децентрализираната финансова система, изградена върху Етереум. Този преглед показва какво може да направите." + "page-eth-whats-defi-description": "DeFi е децентрализираната финансова система, изградена върху Ethereum. Този преглед показва какво може да направите.", + "page-what-is-ethereum-what-is-ether": "Както е това етер?" } diff --git a/src/intl/bg/page-get-eth.json b/src/intl/bg/page-get-eth.json index 90bdbd09dbe..f8e45a08f72 100644 --- a/src/intl/bg/page-get-eth.json +++ b/src/intl/bg/page-get-eth.json @@ -1,16 +1,19 @@ { + "page-get-eth-article-keeping-crypto-safe": "Ключът към сигурността на вашата криптовалута", + "page-get-eth-article-protecting-yourself": "Защита за вас и вашите средства", + "page-get-eth-article-store-digital-assets": "Как да съхраняваме дигитални активи в Eтереум", "page-get-eth-cex": " Централизирани борси", "page-get-eth-cex-desc": "Борсите са бизнеси, които ви позволяват да купувате крипто, използвайки традиционни валути. Те имат контрол върху всички ETH, които купувате, докато не ги изпратите в портфейл под ваш контрол.", "page-get-eth-checkout-dapps-btn": "Вижте dapps", "page-get-eth-community-safety": "Публикации на общността за сигурността", - "page-get-eth-description": "Етереум и ETH не са под контрола на никое правителство или фирма – те са децентрализирани. Това прави ETH отворен за ползване от всеки.", + "page-get-eth-description": "Ethereum и ETH не са под контрола на никое правителство или фирма – те са децентрализирани. Това прави ETH отворен за ползване от всеки.", "page-get-eth-dex": "Децентрализирани борси (DEXs)", "page-get-eth-dex-desc": "Ако искате повече контрол, тогава купувайте ETH от точка-до-точка. При DEX може да търгувате, без да разрешавате на дадена централизирана компания да контролира сумите ви.", "page-get-eth-dexs": "Децентрализирани борси (DEXs)", "page-get-eth-dexs-desc": "Децентрализираните борси са отворени пазари за ETH и други токени. Те директно свързват купувачите с продавачите.", "page-get-eth-dexs-desc-2": "Вместо да използват доверена трета страна да следи за сигурността на сумите в трансакцията, те използват код. ETH на продавача може да бъде прехвърлен само когато плащането е гарантирано. Този вид код е известен като умен договор.", "page-get-eth-dexs-desc-3": "Това означава, че има по-малко географски ограничения отколкото при централизираните алтернативи. Ако някой продава това, което искате, и приема начина ви на плащане, който предлагате, сделката е готова. DEX ви позволява да купите ETH с други токени, чрез PayPal или даже доставени лично в брой.", - "page-get-eth-do-not-copy": "ПРИМЕР: НЕ КОПИРАЙТЕ", + "page-get-eth-do-not-copy": "Пример: Не копирайте", "page-get-eth-exchanges-disclaimer": "Тази информация сме събирали ръчно. Ако забележите някаква нередност, може да ни съобщите на", "page-get-eth-exchanges-empty-state-text": "Изберете вашата държава на пребиваване, за да видите списък с портфейли и борси, които може да използвате, за да купите ETH", "page-get-eth-exchanges-except": "С изключение на", @@ -21,6 +24,7 @@ "page-get-eth-exchanges-no-exchanges": "Съжаляваме, нямаме информация за борси, на които можете да продавате ETH от тази държава. Ако знаете за такива, информирайте ни на", "page-get-eth-exchanges-no-exchanges-or-wallets": "Съжаляваме, нямаме информация за борси или портфейли, които ще ви позволят да купувате ETH от тази държава. Ако знаете за такива, информирайте ни на", "page-get-eth-exchanges-no-wallets": "Съжаляваме, нямаме информация за портфейли, които ще ви позволят да купувате ETH от тази държава. Ако знаете за такива, информирайте ни на", + "page-get-eth-exchanges-search": "Напишете къде живеете...", "page-get-eth-exchanges-success-exchange": "Регистрацията в борса може да отнеме няколко дни, поради съответните законови проверки.", "page-get-eth-exchanges-success-wallet-link": "портфейли", "page-get-eth-exchanges-success-wallet-paragraph": "Там, където живеете, може да купувате ETH направо от тези портфейли. Научете повече за", @@ -39,9 +43,9 @@ "page-get-eth-security": "Но това също означава, че вие трябва сериозно да се погрижите за сигурността на своите средства. С ETH вие не разчитате на дадена банка да се грижи за парите ви, а разчитате на себе си.", "page-get-eth-smart-contract-link": "Повече за умните договори", "page-get-eth-swapping": "Разменяйте своите токени с ETH на други хора. И обратното.", - "page-get-eth-try-dex": "Опитайте Dex (децентрализирана борса)", + "page-get-eth-try-dex": "Пробвайте DEX", "page-get-eth-use-your-eth": "Използвайте вашите ETH", - "page-get-eth-use-your-eth-dapps": "След като вече притежавате малко ETH, вижте някои приложения на Етереум (dapps). Има dapps за финанси, социални медии, игри и много други категории.", + "page-get-eth-use-your-eth-dapps": "След като вече притежавате малко ETH, вижте някои приложения на Ethereum (dapps). Има dapps за финанси, социални медии, игри и много други категории.", "page-get-eth-wallet-instructions": "Следвайте указанията от портфейла", "page-get-eth-wallet-instructions-lost": "Ако загубите достъпа до своя портфейл, вие губите достъп до средствата си. Вашият портфейл би трябвало да ви даде указания как да го пазите. Следвайте ги внимателно – в повечето случаи никой не може да ви помогне, ако загубите достъп към портфейла си.", "page-get-eth-wallets": "Портфейли", diff --git a/src/intl/bg/page-wallets-find-wallet.json b/src/intl/bg/page-wallets-find-wallet.json index c9ddcec9b4f..cca0a8c7aae 100644 --- a/src/intl/bg/page-wallets-find-wallet.json +++ b/src/intl/bg/page-wallets-find-wallet.json @@ -3,14 +3,92 @@ "page-find-wallet-desc-2": "Така че изберете своя портфейл въз основа на характеристиките, които търсите.", "page-find-wallet-description": "Портфейлите имат много допълнителни характеристики, които може да ви допаднат.", "page-find-wallet-last-updated": "Последно обновен", - "page-find-wallet-meta-description": "Намерете и сравнете портфейлите в Етереум на базата на характеристиките, които търсите.", - "page-find-wallet-meta-title": "Намерете портфейл в Етереум", + "page-find-wallet-meta-description": "Намерете и сравнете портфейлите в Ethereum на базата на характеристиките, които търсите.", + "page-find-wallet-meta-title": "Намерете портфейл в Ethereum", "page-find-wallet-title": "Намерете портфейл", "page-find-wallet-try-removing": "Опитайте се да премахнете една-две характеристики", + "page-find-wallet-choose-to-compare": "Изберете, за да сравните", "page-stake-eth": "Залагайте ETH", - "page-find-wallet-swaps": "Размяна на децентрализирани токени", - "page-find-wallet-swaps-desc": "Търгувайте между ETH и останалите токени направо от портфейла си.", - "page-find-wallet-multisig": "Акаунти с няколко подписа", - "page-find-wallet-multisig-desc": "За допълнителна сигурност портфейлите с няколко подписа изискват повече от един акаунт, който да оторизира определени трансакции.", - "page-find-wallet-showing": "Показване " + "page-find-wallet-open-source": "Open source", + "page-find-wallet-open-source-desc": "Софтуерът с отворен код позволява на всеки да ревизира неприкосновеността и сигурността на приложението", + "page-find-wallet-self-custody": "Self custody", + "page-find-wallet-non-custodial": "Без попечител", + "page-find-wallet-non-custodial-desc": "Портфейли, които не контролират личните ви ключове", + "page-find-wallet-hardware-wallet-support": "Поддръжка за хардуер портфейл", + "page-find-wallet-hardware-wallet-support-desc": "Портфейли, които могат да се свързват към хардуерен портфейл за по-голяма сигурност", + "page-find-wallet-walletconnect": "WalletConnect", + "page-find-wallet-walletconnect-desc": "Портфейли които поддържат WalletConnect за свързване към dapps", + "page-find-wallet-rpc-importing": "RPC импортиране", + "page-find-wallet-rpc-importing-desc": "Портфейли, поддържащи персонализирани RPC крайни точки за свързване към различни възли или мрежи", + "page-find-wallet-nft-support": "Поддръжка на NFT", + "page-find-wallet-nft-support-desc": "Портфейли, които поддържат преглеждане и взаимодействие с вашите NFT", + "page-find-wallet-connect-to-dapps": "Връзка към dapps", + "page-find-wallet-connect-to-dapps-desc": "Портфейли, които се свързват към приложения, изградени в платформата на Етереум", + "page-find-wallet-staking": "Залагане", + "page-find-wallet-staking-desc": "Залагайте ETH директно от портфейла", + "page-find-wallet-swaps": "Размени", + "page-find-wallet-swaps-desc": "Разменяйте токени ERC-20 директно от портфейла", + "page-find-wallet-layer-2": "Слой 2", + "page-find-wallet-layer-2-desc": "Портфейли, поддържащи слой 2 на Етереум", + "page-find-wallet-gas-fee-customization": "Персонализиране на таксата за газ", + "page-find-wallet-gas-fee-customization-desc": "Персонализирайте сумите си за газ (базова такса, такса за приоритет и максимална такса)", + "page-find-wallet-ens-support": "Поддръжка на ENS", + "page-find-wallet-ens-support-desc": "Портфейли, поддържащи Обслужване на Имена в Етереум (ENS)", + "page-find-wallet-token-importing": "Внос на токени", + "page-find-wallet-token-importing-desc": "Импортирайте който и да е ERC-20 токен, за да го използвате в портфейла", + "page-find-wallet-fee-optimization": "Оптимизиране на такси", + "page-find-wallet-fee-optimization-desc": "Поддръжка на трансакции от тип 2 за оптимизиране на таксите за газ и възстановяване на средствата за неизползван газ", + "page-find-wallet-buy-crypto": "Купете криптовалута", + "page-find-wallet-buy-crypto-desc": "Купете криптовалута с фиатни средства директно в портфейла \n *Бележка: купуването на криптовалута може да зависи от региона", + "page-find-wallet-sell-for-fiat": "Продайте за фиатни валути", + "page-find-wallet-sell-for-fiat-desc": "Продайте криптовалута срещу фиатни средства директно в портфейла \n *Бележка: тегленето на криптовалута може да зависи от региона", + "page-find-wallet-multisig": "Множество подписи", + "page-find-wallet-multisig-desc": "Портфейли, които изискват множество подписи за разрешаване на трансакция", + "page-find-wallet-social-recovery": "Социално възстановяване", + "page-find-wallet-social-recovery-desc": "Портфейли, които позволяват на попечителите да сменят ключа за влизане на портфейли с интелигентни договори", + "page-find-wallet-token-support": "Поддръжка на токени", + "page-find-wallet-features": "Характеристики", + "page-find-wallet-security": "Сигурност", + "page-find-wallet-smart-contract": "Smart contract", + "page-find-wallet-check-out": "Проверете", + "page-find-wallet-info-updated-on": "информацията е обновена на", + "page-find-wallet-showing-all-wallets": "Показване на всички портфейли", + "page-find-wallet-showing": "Показване ", + "page-find-wallet-wallets": "портфейли", + "page-find-wallet-iOS": "iOS", + "page-find-wallet-android": "Android", + "page-find-wallet-linux": "Linux", + "page-find-wallet-macOS": "macOS", + "page-find-wallet-windows": "Windows", + "page-find-wallet-chromium": "Chromium", + "page-find-wallet-firefox": "Firefox", + "page-find-wallet-hardware": "Хардуер", + "page-find-wallet-hardware-desc": "Хардуерни портфейли", + "page-find-wallet-new-to-crypto-title": "Нов в криптовалутите", + "page-find-wallet-new-to-crypto-desc": "Вие сте нов потребител и търсите своя пръв портфейл", + "page-find-wallet-nfts-title": "NFT", + "page-find-wallet-nfts-desc": "Вие сте човек, който много се вълнува от NFT и искате портфейл, който поддържа NFT", + "page-find-wallet-hodler-title": "Притежател", + "page-find-wallet-hodler-desc": "Вие сте притежател на токени и не искате да ги докосвате", + "page-find-wallet-finance-title": "Финанси", + "page-find-wallet-finance-desc": "Вие сте човек, който използва DeFi, и искате портфейл, който позволява свързване с приложения за DeFi", + "page-find-wallet-developer-title": "Разработчик", + "page-find-wallet-developer-desc": "Вие сте разработчик и се нуждаете от портфейл, с помощта на който да разработвате и тествате децентрализирани приложения", + "page-find-wallet-persona-desc": "Изберете профил, който да отговаря на вашия тип потребител, и филтрирайте списъка с портфейли", + "page-find-wallet-filters": "Филтри", + "page-find-wallet-active": "активно", + "page-find-wallet-profile-filters": "Филтри на профила", + "page-find-wallet-feature-filters": "Филтри на функции", + "page-find-wallet-footnote-1": "Портфейлите, изброени на тази страница, не са официално одобрение и са предоставени само с информационни цели.", + "page-find-wallet-footnote-2": "Техните описания са предоставени от самите проекти на портфейлът.", + "page-find-wallet-footnote-3": "Ние добавяме продукти на тази страница на базата на критерия на нашата политика за списъците . Ако искате да добавим портфейл направете запитване в GitHub.", + "page-find-wallet-mobile": "Мобилен", + "page-find-wallet-mobile-desc": "Портфейли с мобилни приложения", + "page-find-wallet-desktop": "Десктоп", + "page-find-wallet-desktop-desc": "Портфейли с приложения за десктоп", + "page-find-wallet-browser": "Браузър", + "page-find-wallet-browser-desc": "Портфейли с разширения за браузър", + "page-find-wallet-device": "Устройство", + "page-find-choose-to-compare": "Изберете, за да сравните", + "page-find-wallet-choose-features": "Изберете характеристики" } diff --git a/src/intl/bg/page-wallets.json b/src/intl/bg/page-wallets.json index 6aff6e3e574..79ad81f5168 100644 --- a/src/intl/bg/page-wallets.json +++ b/src/intl/bg/page-wallets.json @@ -1,38 +1,38 @@ { "page-wallets-accounts-addresses": "Портфейли, акаунти и адреси", "page-wallets-accounts-addresses-desc": "Струва си да разберете разликите между някои основни термини.", - "page-wallets-accounts-ethereum-addresses": "Акаунтът в Етереум има свой адрес в Етереум, така както пощенската кутия има имейл адрес. Вие може да ползвате това, за да изпратите суми към даден акаунт.", - "page-wallets-alt": "Илюстрация на робот с тяло като свод, изобразяваща портфейл в Етереум", - "page-wallets-ethereum-account": "Акаунтът в Етереум е мястото, откъдето може да правите трансакции, и което има своя баланс.", + "page-wallets-accounts-ethereum-addresses": "Акаунтът в Ethereum има свой адрес в Ethereum, така както пощенската кутия има имейл адрес. Вие може да ползвате това, за да изпратите суми към даден акаунт.", + "page-wallets-alt": "Илюстрация на робот с тяло като свод, изобразяваща портфейл в Ethereum", + "page-wallets-ethereum-account": "Акаунтът в Ethereum е мястото, откъдето може да правите трансакции, и което има своя баланс.", "page-wallets-blog": "Блогът на Coinbase", "page-wallets-bookmarking": "Отбележи своя портфейл", "page-wallets-bookmarking-desc": "Ако използвате портфейл в мрежата, отбележете страницата, за да се защитите от фишинг измами.", - "page-wallets-cd": "Физически портфейли на твърд диск, които ви дават възможност да държите криптовалутата си офлайн – много надеждни", + "page-wallets-cd": "Физическите хардуерни портфейли са устройства, които ви дават възможност да държите криптовалутата си офлайн – много надеждно", "page-wallets-desc-2": "За да изпращате суми и управлявате своите ETH, ви е нужен портфейл.", "page-wallets-desc-2-link": "Повече за ETH", - "page-wallets-desc-3": "Вашият портфейл е само пособие за управление на вашия акаунт в Етереум. Това означава, че може да сменяте доставчиците на портфейли по всяко време. Много от портфейлите също така ви позволяват да управлявате няколко акаунта в Етереум от едно приложение.", + "page-wallets-desc-3": "Вашият портфейл е само пособие за управление на вашия акаунт в Ethereum. Това означава, че може да сменяте доставчиците на портфейли по всяко време. Много от портфейлите също така ви позволяват да управлявате няколко акаунта в Ethereum от едно приложение.", "page-wallets-desc-4": "Това е така, защото портфейлите не са настойници на средствата ви, това сте вие самите. Те са само средство за управление на това, което наистина е ваше.", - "page-wallets-description": "Портфейлите в Етереум са приложения, които ви позволяват да работите с вашия акаунт в Етереум. Представете си, че това е приложение за интернет банкиране – без банка. Вашият портфейл ви показва какъв е балансът ви, изпраща трансакции и се свързва с приложения.", + "page-wallets-description": "Портфейлите в Ethereum са приложения, които ви позволяват да работите с вашия акаунт в Ethereum. Представете си, че това е приложение за интернет банкиране – без банка. Вашият портфейл ви показва какъв е балансът ви, изпраща трансакции и се свързва с приложения.", "page-wallets-desktop": "Десктоп приложения, ако предпочитате да управлявате средствата си през MacOS, Windows или Linux", - "page-wallets-ethereum-wallet": "Портфейлът е продукт, който ви позволява да управлявате своя акаунт в Етереум. Той ви дава възможност да видите своя баланс, да извършвате трансакции и др.", - "page-wallets-explore": "Разучете Етереум", + "page-wallets-ethereum-wallet": "Портфейлът е продукт, който ви позволява да управлявате своя акаунт в Ethereum. Той ви дава възможност да видите своя баланс, да извършвате трансакции и др.", + "page-wallets-explore": "Разучете Ethereum", "page-wallets-features-desc": "Може да ви помогнем да изберете своя портфейл съгласно характеристиките, на които държите.", - "page-wallets-features-title": "Предпочитате да изберете съгласно характеристиките?", + "page-wallets-features-title": "Сравнете портфейлите на база на техните характеристики", "page-wallets-find-wallet-btn": "Намерете портфейл", "page-wallets-find-wallet-link": "Намерете портфейл", "page-wallets-get-some": "Вземете малко ETH", "page-wallets-get-some-alt": "Илюстрация на ръка, създаваща логото на ETH, направено от тухлички на лего", "page-wallets-get-some-btn": "Вземете малко ETH", - "page-wallets-get-some-desc": "ETH е собствената криптовалута на Етереум. За да използвате приложенията в Етереум, имате нужда от малко ETH в портфейла си.", - "page-wallets-how-to-store": "Как да съхраняваме дигитални активи в Етереум", + "page-wallets-get-some-desc": "ETH е собствената криптовалута на Ethereum. За да използвате приложенията в Ethereum, имате нужда от малко ETH в портфейла си.", + "page-wallets-how-to-store": "Как да съхраняваме дигитални активи в Ethereum", "page-wallets-keys-to-safety": "Ключът към сигурността на вашата криптовалута", "page-wallets-manage-funds": "Приложение за управление на вашите активи", "page-wallets-manage-funds-desc": "Вашият портфейл ви показва баланса, историята на трансакциите и как да изпращате/получавате суми. Някои портфейли може да предлагат повече функционалности.", - "page-wallets-meta-description": "Какво трябва да знаете, за да използвате портфейлите на Етереум.", - "page-wallets-meta-title": "Портфейлите на Етереум", + "page-wallets-meta-description": "Какво трябва да знаете, за да използвате портфейлите на Ethereum.", + "page-wallets-meta-title": "Портфейлите на Ethereum", "page-wallets-mobile": "Мобилни приложения, които правят активите ви достъпни отвсякъде", "page-wallets-more-on-dapps-btn": "Повече за Dapps", - "page-wallets-most-wallets": "Повечето от продуктите на портфейлите ще ви позволят да създадете акаунт в Етереум. Така че нямате нужда от такъв, преди да си свалите портфейл.", + "page-wallets-most-wallets": "Повечето от продуктите на портфейлите ще ви позволят да създадете акаунт в Ethereum. Така че нямате нужда от такъв, преди да си свалите портфейл.", "page-wallets-protecting-yourself": "За защита на вас и вашите суми", "page-wallets-seed-phrase": "Напишете своя комплект от думи", "page-wallets-seed-phrase-desc": "Портфейлите често идват с комплект от думи, които трябва да запишете на сигурно място. Това е единственият начин да успеете да възстановите портфейла си.", @@ -42,22 +42,26 @@ "page-wallets-slogan": "Ключът към вашето дигитално бъдеще", "page-wallets-stay-safe": "Как да бъдем в безопасност", "page-wallets-stay-safe-desc": "Портфейлите са нещо като промяна в мисленето. Финансовата свобода и възможността за достъп и употреба на сумите, откъдето и да е, идва с определена отговорност – в крипто света няма отдел за обслужване на клиенти.", - "page-wallets-subtitle": "Портфейлите ви дават достъп до сумите ви и приложенията в Етереум. Само вие трябва да имате достъп до вашия портфейл.", + "page-wallets-subtitle": "Портфейлите ви дават достъп до сумите ви и приложенията в Ethereum. Само вие трябва да имате достъп до вашия портфейл.", "page-wallets-take-responsibility": "Поемете отговорност за собствените си средства", "page-wallets-take-responsibility-desc": "Централизираните борси ще свържат портфейла ви с потребителско име и парола, така че да можете да го възстановите по традиционния начин. Само помнете, че като се доверявате на дадена борса, вие й давате права върху активите си. Ако тази компания бъде хакната или се разпадне, вие рискувате вашите активи.", "page-wallets-tips": "Повече за това как да бъдете в безопасност", "page-wallets-tips-community": "От общността", - "page-wallets-title": "Портфейлите на Етереум", + "page-wallets-title": "Портфейлите на Ethereum", "page-wallets-triple-check": "Проверявайте всичко по три пъти", "page-wallets-triple-check-desc": "Помнете, че не може да върнете трансакциите назад и портфейлите не могат да бъдат възстановени лесно, така че вземете мерки и внимавайте винаги.", "page-wallets-try-dapps": "Опитайте с някои dapps", - "page-wallets-try-dapps-alt": "Илюстрация как членове на общността на Етереум работят заедно", - "page-wallets-try-dapps-desc": "Dapps са приложения, изградени върху Етереум. Те са по-евтини, по-честни и внимателни към вашите данни, отколкото повечето от традиционните приложения.", + "page-wallets-try-dapps-alt": "Илюстрация как членове на общността на Ethereum работят заедно", + "page-wallets-try-dapps-desc": "Dapps са приложения, изградени върху Ethereum. Те са по-евтини, по-честни и внимателни към вашите данни, отколкото повечето от традиционните приложения.", "page-wallets-types": "Видове портфейли", - "page-wallets-web-browser": "Уеб портфейли, които ви позволяват да работите с акаунта си през уеб браузър", - "page-wallets-whats-a-wallet": "Какво е портфейл в Етереум?", - "page-wallets-your-ethereum-account": "Вашият акаунт в Етереум", - "page-wallets-your-ethereum-account-desc": "Вашият портфейл е вашият прозорец към акаунта ви в Етереум – баланс, история на трансакциите и други. Вие обаче може да смените доставчиците на портфейли по всяко време.", - "page-wallets-your-login": "Вашата регистрация за приложенията в Етереум", - "page-wallets-your-login-desc": "Вашият портфейл ви позволява да се свържете с което и да е децентрализирано приложение, като ползвате акаунта си в Етереум. Това е като регистрация, която може да ползвате в много dapps." + "page-wallets-types-desc": "Има няколко начина, по които да се свържете и взаимодействате с вашия акаунт:", + "page-wallets-web-browser": "Браузър портфейлите са уеб приложения, които ви позволяват да работите с вашия акаунт направо в браузъра", + "page-wallets-web-browser-extension": "Браузър портфейлите с разширения са такива, които може да свалите и които ви дават възможност да работите с вашите акаунти и приложения през браузъра", + "page-wallets-whats-a-wallet": "Какво е портфейл в Ethereum?", + "page-wallets-your-ethereum-account": "Вашият акаунт в Ethereum", + "page-wallets-your-ethereum-account-desc": "Вашият портфейл е вашият прозорец към акаунта ви в Ethereum – баланс, история на трансакциите и други. Вие обаче може да смените доставчиците на портфейли по всяко време.", + "page-wallets-your-login": "Вашата регистрация за приложенията в Ethereum", + "page-wallets-your-login-desc": "Вашият портфейл ви позволява да се свържете с което и да е децентрализирано приложение, като ползвате акаунта си в Ethereum. Това е като регистрация, която може да ползвате в много dapps.", + "additional-reading-how-to-register-an-ethereum-account": "Как да „регистрирате“ акаунт в Етереум", + "additional-reading-how-to-use-a-wallet": "Как се използва портфейл" } diff --git a/src/intl/bg/page-what-is-ethereum.json b/src/intl/bg/page-what-is-ethereum.json index 3c1ebcfb048..7615abab3fd 100644 --- a/src/intl/bg/page-what-is-ethereum.json +++ b/src/intl/bg/page-what-is-ethereum.json @@ -1,26 +1,117 @@ { - "page-what-is-ethereum-alt-img-bazaar": "Илюстрация на човек, който наднича в един пазар, направен да представлява Етереум", - "page-what-is-ethereum-alt-img-comm": "Илюстрация как членове на общността на Етереум работят заедно", + "page-what-is-ethereum-alt-img-bazaar": "Илюстрация на човек, който наднича в един пазар, направен да представлява Ethereum", + "page-what-is-ethereum-alt-img-comm": "Илюстрация как членове на общността на Ethereum работят заедно", "page-what-is-ethereum-alt-img-lego": "Илюстрация на ръка, създаваща логото на ETH, направено от тухлички на лего", "page-what-is-ethereum-banking-card": "Банкиране за всеки", - "page-what-is-ethereum-banking-card-desc": "Не всеки има достъп до финансови услуги. Но всичко, от което имате нужда, за да влезете в Етереум и неговата система на даване и вземане на заеми и на спестявания, е интернет връзка.", - "page-what-is-ethereum-build": "Направете нещо с Етереум", - "page-what-is-ethereum-build-desc": "Ако желаете да опитате да изграждате с Етереум, четете нашата документация или проверете инструментите, с които трябва да започнете.", + "page-what-is-ethereum-banking-card-desc": "Не всеки има достъп до финансови услуги. Но всичко, от което имате нужда, за да влезете в Ethereum и неговата система на даване и вземане на заеми и на спестявания, е интернет връзка.", + "page-what-is-ethereum-build": "Направете нещо с Ethereum", + "page-what-is-ethereum-build-desc": "Ако желаете да опитате да изграждате с Ethereum, четете нашата документация или проверете инструментите, с които трябва да започнете.", "page-what-is-ethereum-censorless-card": "Устойчивост на цензура", - "page-what-is-ethereum-censorless-card-desc": "Никое правителство или фирма няма контрол над Етереум. Тази децентрализация прави почти невъзможно някой да се опита да ви попречи да получавате плащания или да използвате услугите в Етереум.", + "page-what-is-ethereum-censorless-card-desc": "Никое правителство или фирма няма контрол над Ethereum. Тази децентрализация прави почти невъзможно някой да се опита да ви попречи да получавате плащания или да използвате услугите в Ethereum.", "page-what-is-ethereum-comm-desc": "Нашата общност включва хора от всякакво потекло, включително артисти, крипто-анархисти, компании от 500-те най-големи такива, а сега и вас. Научете как може да се включите още днес.", "page-what-is-ethereum-commerce-card": "Гаранции за търговията", - "page-what-is-ethereum-commerce-card-desc": "Етереум създава повече пространство за развитие. Клиентите имат сигурна, вградена в системата гаранция, че средствата ще сменят своя собственик само ако действате спрямо уговорката. Нямате нужда от протекцията на голяма компания, за да работите.", - "page-what-is-ethereum-community": "Общността на Етереум", + "page-what-is-ethereum-commerce-card-desc": "Клиентите имат сигурна вградена гаранция за това, че средствата ще преминат от едни ръце към други само ако се спазят предварителните договорености. По същия начин разработчиците могат да бъдат уверени, че правилата за тях няма да се променят.", + "page-what-is-ethereum-composable-card": "Всички продукти са съставни", + "page-what-is-ethereum-composable-card-desc": "Тъй като всички приложения са изградени на същия блокчейн с една споделена глобална структура, те могат да се изграждат едно от друго (също като LEGO). Това позволява непрекъснато да бъдат разработвани все по-добри продукти и стратегии.", + "page-what-is-ethereum-community": "Общността на Ethereum", "page-what-is-ethereum-desc": "Основата на нашето дигитално бъдеще", - "page-what-is-ethereum-explore": "Разучете Етереум", + "page-what-is-ethereum-explore": "Разучете Ethereum", "page-what-is-ethereum-internet-card": "По-поверителен интернет", - "page-what-is-ethereum-internet-card-desc": "Няма нужда да давате всичките си лични данни, за да ползвате приложение в Етереум. Етереум гради икономика на основата на стойност, а не на наблюдение.", + "page-what-is-ethereum-internet-card-desc": "Няма нужда да давате всичките си лични данни, за да ползвате приложение в Ethereum. Ethereum гради икономика на основата на стойност, а не на наблюдение.", "page-what-is-ethereum-meet-comm": "Запознайте се с общността", - "page-what-is-ethereum-meta-description": "Научете какво е Етереум, какво прави и как сами да го пробвате.", - "page-what-is-ethereum-meta-title": "Какво е Етереум?", + "page-what-is-ethereum-meta-description": "Научете какво е Ethereum, какво прави и как сами да го пробвате.", + "page-what-is-ethereum-meta-title": "Какво е Ethereum?", "page-what-is-ethereum-p2p-card": "Мрежа с равноправен достъп", - "page-what-is-ethereum-p2p-card-desc": "Етереум ви позволява да прехвърляте суми или да сключвате договори директно с някой друг. Няма нужда да минавате през фирми-посредници.", + "page-what-is-ethereum-p2p-card-desc": "Ethereum ви позволява да прехвърляте суми или да сключвате договори директно с някой друг. Няма нужда да минавате през фирми-посредници.", "page-what-is-ethereum-start-building-btn": "Започнете да изграждате", - "page-what-is-ethereum-title": "Какво е Етереум?" + "page-what-is-ethereum-title": "Какво е Ethereum?", + "page-what-is-ethereum-subtitle": "Изчерпателно ръководство за начинаещи относно това как работи Етереум, ползите, които носи, и как се използва от милиони хора по света.", + "page-what-is-ethereum-button-lets-start": "Да започваме", + "page-what-is-ethereum-blockchain-tab-title": "Какво е блокчейн?", + "page-what-is-ethereum-blockchain-tab-content": "Блокчейнът е база данни с трансакции, която се обновява и споделя с много компютри в мрежа. Всеки път, когато се добавя нов набор от трансакции, това се нарича „блок“ – от тук и името блокчейн. Повечето блокчейни са публични и може само да добавяте данни, но не и да премахвате. Ако някой поиска да промени която и да е информация или да измами системата, той ще трябва да направи това на болшинството от компютрите в мрежата. А те са доста! Това дава на утвърдени блокчейни като Етереум високо ниво на сигурност.", + "page-what-is-ethereum-cryptocurrency-tab-title": "Защо се нарича криптовалута?", + "page-what-is-ethereum-cryptocurrency-tab-content": "Блокчейните използват криптографски техники, за да подсигурят безопасността на средствата ви. Подобни техники с години са били използвани в банковия сектор за гарантиране на сигурността на паричните трансакции. Така че може да се каже, че нивото на сигурност на криптовалутите е като на банките.", + "page-what-is-ethereum-summary-title": "Обобщение", + "page-what-is-ethereum-summary-desc-1": "Етереум е мрежа, съставена от много общности и набор от инструменти, които позволяват на хората да извършват трансакции и да комуникират, без да бъдат контролирани от централна власт. Не е необходимо да предоставяте всичките си лични данни, за да използвате Етереум – запазвате контрола върху собствените си данни и върху това, което се споделя. Етереум има собствена криптовалута, етер, която се използва за заплащането за определени дейности в мрежата на Етереум.", + "page-what-is-ethereum-summary-desc-2": "Още ли се чувствате объркани? Нека обясним всичко стъпка по стъпка.", + "page-what-is-ethereum-what-is-crypto-title": "Какво е това криптовалута?", + "page-what-is-ethereum-what-is-crypto-desc-1": "Крипто (краткото име за криптовалута) е нова форма на дигитални пари, създадена чрез криптография.", + "page-what-is-ethereum-what-is-crypto-desc-2": "Всичко започна през 2008 г. с Биткойн. Може да се използва за изпращане на средства до всеки и във всяка точка на света. Това, което прави криптовалутата различна от традиционните банкови преводи или други финансови услуги като Paypal или Alipay, е това, че за първи път няма посредник.", + "page-what-is-ethereum-what-is-crypto-desc-3": "Един момент, а какво е това посредник?", + "page-what-is-ethereum-what-is-crypto-desc-4": "Посредникът е централна институция с власт, като банка или правителство, която се намесва в трансакцията между изпращащия и получателя. Те имат властта да наблюдават, цензурират или връщат трансакциите и могат да споделят чувствителни данни, които събират за вас, с трети страни. Те също така диктуват до кои финансови услуги да имате достъп.", + "page-what-is-ethereum-what-is-crypto-desc-5": "Нещата стоят различно при криптото. Транзакциите свързват директно изпращача и получателя без да се налага да се занимавате с каквато и да е централна власт и никой не може да ви каже кои услуги може да ползвате. Това е възможно заради блокчейн технологията, върху която работят криптовалутите.", + "page-what-is-ethereum-btc-eth-diff-title": "Каква е разликата между Етереум и Биткойн?", + "page-what-is-ethereum-btc-eth-diff-1": "Въведен през 2015 г., Етереум е изграден на основата на иновацията на Биткойн, но с няколко големи разлики.", + "page-what-is-ethereum-btc-eth-diff-2": "И двете ви позволяват да използвате дигитални пари без посредници за плащания или банки. Но Етереум може да се програмира, така че вие можете също и да изграждате и разполагате децентрализирани приложения в неговата мрежа.", + "page-what-is-ethereum-btc-eth-diff-3": "Биткойн ни позволява да изпращаме базови съобщения помежду си относно това, което намираме за ценно. Установяването на ценност без власт е вече могъщо. Етереум надгражда върху това: вместо само съобщения, вие можете да напишете всякаква обща програма или договор. Няма лимит върху типа договори, които могат да бъдат създавани и договаряни, следователно в платформата на Етереум се случва страхотна иновация.", + "page-what-is-ethereum-btc-eth-diff-4": "Докато Биткойн е само мрежа за плащания, Етереум прилича повече на пазар за финансови услуги, игри, социални мрежи и други приложения, които уважават вашата поверителност и не могат да ви цензурират.", + "page-what-is-ethereum-what-can-eth-do-title": "Какво може да прави Етереум?", + "page-what-is-ethereum-why-would-i-use-ethereum-title": "Защо ми е да използвам Етереум?", + "page-what-is-ethereum-why-would-i-use-ethereum-1": "Ако някога сте се опитвали да изпращате пари в чужбина (или смятате да го направите), или сте се тревожили за бъдещето на активите си поради външни сили извън вашия контрол там, където живеете, или ви е омръзнало от безбройните ограничения и такси, налагани от традиционните финансови институции при ежедневните трансакции, то може да ви бъде интересно това, което предлагат криптовалутите.", + "page-what-is-ethereum-why-would-i-use-ethereum-2": "Ако се интересувате от по-устойчиви, отворени и надеждни начини да създавате и споделяте стойност, Етереум е за вас. Етереум е историята, написана от всички нас, затова елате и открийте какви невероятни светове можем да създадем заедно.", + "page-what-is-ethereum-slide-1-title": "По-евтини и по-бързи трансгранични плащания", + "page-what-is-ethereum-slide-1-desc-1": "Стейбълкойните са нова разновидност на криптовалутата, при която се разчита на по-стабилни активи като основа за стойността им. Повечето от тях са свързани с щатския долар и следователно поддържат стойността на тази валута. Те дават възможност за една много евтина и стабилна глобална система за разплащания. Много от съществуващите стейбълкойни са изградени върху мрежата на Етереум.", + "page-what-is-ethereum-slide-1-desc-2": "Етереум и стейбълкойните опростяват процеса на изпращане на пари в чужбина. Често отнема само няколко минути, за да бъдат прехвърлени средства по целия свят, което съвсем не е така при една средностатистическа банка, където това отнема няколко работни дни и даже седмици, и при това за малка част от цената за трансакцията. В допълнение, няма отделна такса при трансакциите на големи суми, както и никакви ограничения за това къде или защо изпращате парите си.", + "page-what-is-ethereum-slide-2-title": "Най-бързата помощ във времена на криза", + "page-what-is-ethereum-slide-2-desc-1": "Ако имате късмета да имате многобройни банкови възможности чрез надеждни институции там, където живеете, вероятно приемате за даденост финансовата свобода, сигурност и стабилност, които те предлагат. Но за много хора по света, които се сблъскват с политически репресии или икономически затруднения, финансовите институции може и да не осигуряват защитата или услугите, от които те имат нужда.", + "page-what-is-ethereum-slide-2-desc-2": "Когато войната, икономическите катастрофи или нарушаването на човешките права сполетяха жителите на Венесуела, Куба, Афганистан, Нигерия, Беларус и Украйна, криптовалутите бяха най-бързата, а често и единствената възможност за запазване на финансовата независимост.1 Както е видно от тези примери, криптовалутите като Етереум могат да предоставят неограничен достъп до световната икономика тогава, когато хората са с ограничен достъп до външния свят. Освен това стейбълкойните предлагат запазване на стойността в случаи на срив на местните валути поради хиперинфлация.", + "page-what-is-ethereum-slide-3-title": "Възможности за създателите", + "page-what-is-ethereum-slide-3-desc-1": "Само през 2021 г. артисти, музиканти, писатели и други хора на изкуството са използвали Етереум, за да спечелят общо около 3,5 милиарда долара. Това прави Етереум една от най-големите световни платформи за творци, наред със Spotify, YouTube и Etsy. Научете повече.", + "page-what-is-ethereum-slide-4-title": "Възможности за геймърите", + "page-what-is-ethereum-slide-4-desc-1": "Игрите от типа „Играй, за да печелиш“ (в които играчите наистина получават награди, за да играят) се появиха наскоро и те преобразяват цялата гейминг индустрия. Обикновено често се забранява да се търгуват или прехвърлят активи в игрите на други участници срещу истински пари. Това принуждава играчите да ползват сайтове на черния пазар, които често застрашават сигурността. Игрите на блокчейните приемат икономика в рамките на играта и поощряват такова поведение, но по доверен и сигурен начин.", + "page-what-is-ethereum-slide-4-desc-2": "Нещо повече, играчите се поощряват, защото могат да търгуват с токени от играта за истински пари и така те наистина биват възнаградени за това, че играят.", + "page-what-is-ethereum-meet-ether-title": "Запознайте се с етер – криптовалутата на Етереум", + "page-what-is-ethereum-meet-ether-desc-1": "Етереум има своя собствена криптовалута, наречена етер (ETH). Тя е напълно дигитална и може веднага да я пращате към когото и да е по целия свят. Запасите от ETH не се контролират от никое правителство или фирма – те са децентрализирани и напълно прозрачни. Нови монети (които обикновено се наричат токени) се издават само за залагащи, които подсигуряват мрежата.", + "page-what-is-ethereum-meet-ether-desc-2": "Всяко действие в мрежата на Етереум изисква определена изчислителна мощност. Тази такса се плаща под формата на етер. Това означава, че се нуждаете от поне малко ETH, за да използвате мрежата.", + "page-what-is-ethereum-what-is-ether": "Както е това етер?", + "page-what-is-ethereum-get-eth": "Вземете ETH", + "page-what-is-ethereum-what-can-i-do-title": "Какво мога да правя с монети ETH?", + "page-what-is-ethereum-what-can-i-do-desc-1": "Оказва се, че много! Един от най-известните начини на употреба на технологията на Етереум са децентрализираните финанси (DeFi), които отварят врати от възможности за банкови услуги за всеки, който има интернет връзка. Може да използвате вашият етер и като обезпечение при вземане на заеми или да осигурите ликвидност с цел получаване на лихви от средствата си.", + "page-what-is-ethereum-explore-applications": "Разгледайте приложенията", + "page-what-is-ethereum-learn-defi": "Научете за DeFi", + "page-what-is-ethereum-who-runs-ethereum-title": "Кой управлява Етереум?", + "page-what-is-ethereum-who-runs-ethereum-desc-1": "Етереум не се управлява от който и да е един субект. Съществува единствено чрез децентрализираното участие и сътрудничество на общността. Етереум използва възли (компютри с копие от данните на блокчейна на Етереум), които се управляват от доброволци, които от своя страна заместват личните сървъри и облачни системи, притежавани от големи доставчици на интернет и услуги.", + "page-what-is-ethereum-who-runs-ethereum-desc-2": "Тези разпределени на различни места възли, които се управляват от хора и компании от цял свят, осигуряват устойчивостта на инфраструктурата на мрежата на Етереум. Следователно така тя става по-малко податлива на атаки и блокиране. От самото си създаване през 2015 г., Етереум никога не е спирала да работи.. Има хиляди отделни възли, които управляват мрежата на Етереум. Това я прави всъщност една от най-децентрализираните криптовалути, на второ място след биткойн.", + "page-what-is-ethereum-run-a-node": "Управление на възел", + "page-what-is-ethereum-smart-contract-title": "Какво представляват умните договори?", + "page-what-is-ethereum-smart-contract-desc-1": "Интелигентните договори са просто компютърни програми, съществуващи на блокчейна на Етереум. Те се изпълняват самокогато бъдат задействани от трансакция от потребител (или друг договор.). Те правят Етереум много гъвкав в това, което може да прави, и го отличават от другите криптовалути. Тези програми са това, което сега наричаме децентрализирани приложения или dapps.", + "page-what-is-ethereum-smart-contract-desc-2": "Някога използвали ли сте продукт, който променя условията си за употреба? Или премахва функция, която за вас е полезна? Когато един интелигентен договор е публикуван в Етереум, той остава онлайн и действащ, докато Етереум съществува. Дори неговият автор не може да го премахне. Тъй като интелигентните договори са автоматизирани, те не облагодетелстват едни потребители за сметка на други и са винаги годни за употреба.", + "page-what-is-ethereum-smart-contract-desc-3": "Известни примери за интелигентни договори може да намерим в приложенията за даване на заеми, децентрализираните борси за търговия, застраховките, груповото финансиране – всъщност всичко, за което може да се сетите.", + "page-what-is-ethereum-more-on-smart-contracts": "Повече за интелигентните договори", + "page-what-is-ethereum-explore-dapps": "Проучете dapps", + "page-what-is-ethereum-criminal-activity-title": "Чух, че криптовалутите се ползват за криминални деяния. Това вярно ли е?", + "page-what-is-ethereum-criminal-activity-desc-1": "Както при всички видове парични средства, някои ще бъдат ползвани не по предназначение. Но тъй като всички трансакции в Етереум стават в отворена верига, често за властите е по-лесно да проследят определени незаконни дейности в нея, отколкото в традиционната финансова система, което вероятно прави Етереум по-малко привлекателен избор за тези, които предпочитат да останат незабелязани.", + "page-what-is-ethereum-criminal-activity-desc-2": "Според някои важни разкрития в наскоро публикуван доклад на Европол, Агенцията на ЕС за сътрудничество в прилагането на закона, криптовалутите се използват много по-малко с криминална цел в сравнение с фиатните валути:", + "page-what-is-ethereum-criminal-activity-desc-3": "„Употребата на криптовалутите за незаконни дейности представлява само малка част от цялата икономика с криптовалута, тя видимо е по-малка в сравнение с размера на нелегалните средства в традиционните финанси.“", + "page-what-is-ethereum-energy-title": "Какво да кажем за консумацията на енергия при Етереум?", + "page-what-is-ethereum-energy-desc-1": "На 15 септември 2022 г. Етереум премина през надстройката на Сливането, която отбеляза прехода на Етереум от доказателство-за-работа към доказателство-за-залог.", + "page-what-is-ethereum-energy-desc-2": "Сливането беше най-големият ъпгрейд, който намали консумацията на енергия, нужна да подсигурява Етереум, с 99.95%, създавайки еднапо-сигурна мрежа на много по-малка въглеродна цена. Сега Етереум е ниско-въглеродна верига, която в същото време устоява своята сигурност и мащабируемост.", + "page-what-is-ethereum-more-on-energy-consumption": "Повече за потреблението на енергия", + "page-what-is-ethereum-energy-consumption-chart-legend": "Годишно потребление на енергия в TWh/yr", + "energy-consumption-chart-global-data-centers-label": "Global data centers", + "energy-consumption-gold-mining-cbeci-label": "Gold mining", + "energy-consumption-chart-btc-pow-label": "BTC доказателство за работа", + "energy-consumption-chart-netflix-label": "Netflix", + "energy-consumption-chart-eth-pow-label": "ETH доказателство за работа", + "energy-consumption-chart-gaming-us-label": "Гейминг в САЩ", + "energy-consumption-chart-paypal-label": "PayPal", + "energy-consumption-chart-eth-pos-label": "ETH доказателство за залог", + "page-what-is-ethereum-the-merge-update": "Актуализацията „Сливането“", + "page-what-is-ethereum-additional-reading": "Допълнително четиво", + "page-what-is-ethereum-week-in-ethereum": "Седмични новини за Етереум", + "page-what-is-ethereum-week-in-ethereum-desc": "– седмичен вестник, който отразява важните събития в екосистемата.", + "page-what-is-ethereum-kernel-dreamers": "Kernel", + "page-what-is-ethereum-kernel-dreamers-desc": "Мечтата на Етереум", + "page-what-is-ethereum-atoms-institutions-blockchains": "Атоми, институции, блокчейни", + "page-what-is-ethereum-atoms-institutions-blockchains-desc": "– защо блокчейните имат значение?", + "page-what-is-ethereum-ethereum-in-numbers-title": "Етереум в цифри", + "adoption-chart-column-now-label": "Сега", + "adoption-chart-investors-label": "Инвеститори", + "adoption-chart-developers-label": "Разработчици", + "adoption-chart-companies-label": "Компании", + "adoption-chart-artists-label": "Артисти", + "adoption-chart-musicians-label": "Музиканти", + "adoption-chart-writers-label": "Писатели", + "adoption-chart-gamers-label": "Геймъри", + "adoption-chart-refugees-label": "Бежанци" } diff --git a/src/intl/cs/common.json b/src/intl/cs/common.json index 3acf15085ae..463970b2a05 100644 --- a/src/intl/cs/common.json +++ b/src/intl/cs/common.json @@ -87,7 +87,6 @@ "get-started": "Začít", "grants": "Granty", "grant-programs": "Grantové programy pro ekosystém", - "guides-and-resources": "Příručky a zdroje informací", "guides": "Příručky", "guides-hub": "Výukový hub", "history-of-ethereum": "Historie Etherea", diff --git a/src/intl/da/common.json b/src/intl/da/common.json index 872a4167fc8..737920109d5 100644 --- a/src/intl/da/common.json +++ b/src/intl/da/common.json @@ -1,4 +1,5 @@ { + "account-abstraction": "Konto-abstraktion", "about-ethereum-org": "Om ethereum.org", "about-us": "Om os", "aria-toggle-search-button": "Tænd/sluk søgknappen", @@ -6,25 +7,46 @@ "zen-mode": "Zen-tilstand", "beacon-chain": "Beacon Chain", "bridges": "Blockchain-broer", + "clear": "Ryd", "close": "Luk", "community": "Fællesskab", "community-hub": "Fællesskabs-hub", "community-menu": "Fællesskabs-menu", "contact": "Kontakt", + "content-standardization": "Standardisering af indhold", "contributing": "Bidrager", "contributors": "Bidragere", "contributors-thanks": "Alle der har bidraget til denne side – tak!", "cookie-policy": "Cookiepolitik", "copied": "Kopieret", "copy": "Kopiér", + "danksharding": "Danksharding", "dark-mode": "Mørk", "data-provided-by": "Datakilde:", "decentralized-applications-dapps": "Decentraliserede applikationer (dapps)", + "decentralized-science": "Decentraliseret videnskab (DeSci)", "devcon": "Devcon", "developers": "Udviklere", "developers-home": "Udviklerens startside", "docs": "Dokumenter", + "docsearch-to-select": "For at vælge", + "docsearch-to-navigate": "For at navigere", + "docsearch-to-close": "For at lukke", + "docsearch-search-by": "Søg efter", + "docsearch-start-recent-searches-title": "Seneste", + "docsearch-start-no-recent-searches": "Ingen seneste søgninger", + "docsearch-start-save-recent-search": "Gem denne søgning", + "docsearch-start-remove-recent-search": "Fjern denne søgning fra historikken", + "docsearch-start-favorite-searches": "Foretrukket", + "docsearch-start-remove-favorite-search": "Fjern denne søgning fra foretrukne", + "docsearch-no-results-text": "Ingen resultater for", + "docsearch-no-results-suggested-query": "Prøv at søge efter", + "docsearch-no-results-missing": "Burde denne forespørgsel returnere resultater?", + "docsearch-no-results-missing-link": "Fortæl os om det.", + "docsearch-error-title": "Kunne ikke hente resultater", + "docsearch-error-help": "Du bør kontrollere din netværksforbindelse.", "documentation": "Dokumentation", + "down": "Ned", "ecosystem": "Økosystem", "edit-page": "Redigér side", "ef-blog": "Ethereum Foundation Blog", @@ -59,15 +81,22 @@ "feedback-widget-thank-you-timing": "2–3 min", "feedback-widget-thank-you-cta": "Åbn kort undersøgelse", "find-wallet": "Find tegnebog", + "future-proofing": "Fremtidssikring", "get-eth": "Få ETH", "get-involved": "Vær med", "get-started": "Kom godt i gang", "grants": "Tilskud", "grant-programs": "Økosystem-tilskudsprogrammer", - "guides-and-resources": "Fællesskabsvejledninger og -ressourcer", + "guides": "Guider", + "guides-hub": "Guidehub", "history-of-ethereum": "Ethereums historik", "home": "Startside", "how-ethereum-works": "Sådan fungerer Ethereum", + "how-to-register-an-ethereum-account": "Sådan \"registreres\" en Ethereum konto", + "how-to-revoke-token-access": "Sådan tilbagekalder man smart kontrakt-adgang til sine krypto midler", + "how-to-swap-tokens": "Sådan byttes tokens", + "how-to-use-a-bridge": "Sådan forbindes tokens til lag 2", + "how-to-use-a-wallet": "Sådan bruges en tegnebog", "image": "billede", "in-this-section": "I dette afsnit", "individuals": "Personer", @@ -81,6 +110,7 @@ "layer-2": "Layer 2", "learn": "Lær", "learn-by-coding": "Lær ved kodning", + "learn-hub": "Læringshub", "learn-menu": "Menuen Lær", "learn-more": "Lær mere", "less": "Mindre", @@ -95,22 +125,30 @@ "nav-developers": "Udviklere", "nav-developers-docs": "Udviklerdokumenter", "nav-primary": "Primær", + "nfts": "NFT'er", "no": "Nej", "on-this-page": "På denne side", "open-research": "Åbn søgning", "page-last-updated": "Side senest opdateret", + "pbs": "Separation af proposer-builder", "privacy-policy": "Databeskyttelse", "private-ethereum": "Privat Ethereum", "refresh": "Genindlæs venligst siden.", "return-home": "retur til startside", + "roadmap": "Ethereum køreplan", "run-a-node": "Kør en node", "rollup-component-website": "Websted", "rollup-component-developer-docs": "Udviklerdokumenter", "rollup-component-technology-and-risk-summary": "Teknologi- og risikoopsummering", + "scaling": "Skalering", "search": "Søg", + "search-ethereum-org": "Søg ethereum.org", + "secret-leader-election": "Hemmeligt ledervalg", "search-box-blank-state-text": "Søg alt det du vil!", "search-eth-address": "Dette ligner en Ethereum-adresse. Vi leverer ikke data specifikt til adresser. Prøv at søge efter det på en block-stifinder som", "search-no-results": "Ingen resultater af din søgning", + "single-slot-finality": "Enkeltpladsfinalitet", + "statelessness": "Tilstandsløshed", "see-contributors": "Se bidragydere", "set-up-local-env": "Opsæt lokalt miljø", "sharding": "Sharding", @@ -121,10 +159,13 @@ "skip-to-main-content": "Spring til hovedindholdet", "smart-contracts": "Smart kontrakter", "stablecoins": "Stablecoins", + "stake-eth": "Stake ETH", "staking": "Indskyder", + "style-guide": "Style guide", "solo": "Solo-staking", "saas": "Staking som en tjeneste", "pools": "Samlet staking", + "withdrawals": "Udtrækning af Indsatser", "terms-of-use": "Brugsvilkår", "translation-banner-body-new": "Du ser denne side på engelsk, fordi vi ikke har oversat den endnu. Hjælp os med at oversætte dette indhold.", "translation-banner-body-update": "Der er en ny version af siden, men den er kun på engelsk lige nu. Hjælp os med at oversætte den nyeste version.", @@ -137,19 +178,26 @@ "translation-banner-no-bugs-dont-show-again": "Vis ikke igen", "try-using-search": "Prøv at bruge søgning for at finde det, du leder efter", "tutorials": "Vejledninger", + "up": "Op", "use-ethereum": "Brug Ethereum", "use-ethereum-menu": "Brug Ethereum-menu", + "user-experience": "User experience", + "verkle-trees": "Verkle-træer", "wallets": "Tegnebøger", "we-couldnt-find-that-page": "Vi kunne ikke finde den side", "web3": "Hvad er Web3?", + "web3-title": "Web3", "website-last-updated": "Websted senest opdateret", "what-is-ether": "Hvad er ether (ETH)?", "what-is-ethereum": "Hvad er Ethereum?", "defi-page": "Decentraliserede finanser (DeFi)", - "dao-page": "Decentraliserede, autonome organisationer (DAO'er)", + "dao-page": "Decentraliserede autonome organisationer (DAO'er)", "nft-page": "Ikke-ombyttelige tokens (NFT'er)", "decentralized-social-networks": "Decentraliserede sociale netværk", "decentralized-identity": "Decentraliseret identitet", "yes": "Ja", - "page-index-meta-title": "Hjem" + "zero-knowledge-proofs": "Vidensløse beviser", + "ethereum-roadmap": "Ethereum køreplan", + "page-index-meta-title": "Home", + "page-developers-aria-label": "Developers' Menu" } diff --git a/src/intl/da/page-index.json b/src/intl/da/page-index.json index 8363a3664a2..8f0ee770c65 100644 --- a/src/intl/da/page-index.json +++ b/src/intl/da/page-index.json @@ -6,10 +6,10 @@ "page-index-description": "Ethereum er den fællesskabsdrevne teknologi, der driver cryptovalutaen ether (ETH) og tusindvis af decentraliserede applikationer.", "page-index-title-button": "Udforsk Ethereum", "page-index-get-started": "Kom godt i gang", - "page-index-get-started-description": "ethereum.org er din portal ind i verden af Ethereum. Teknologien er ny og udvikler sig løbende – det hjælper at have en guide. Her er, hvad vi anbefaler dig at gøre, hvis du ønsker at hoppe ombord.", + "page-index-get-started-description": "ethereum.org er din portal ind i Ethereum-verdenen. Teknologien er ny og udvikler sig løbende – det hjælper at have en guide. Her er, hvad vi anbefaler dig at gøre, hvis du ønsker at hoppe ombord.", "page-index-get-started-image-alt": "Illustration af en person siddende ved en computer.", "page-index-get-started-wallet-title": "Vælg en tegnebog", - "page-index-get-started-wallet-description": "En tegnebog lader dig oprette forbindelse til Ethereum og håndtere dine midler.", + "page-index-get-started-wallet-description": "Med en wallet kan man oprette forbindelse til Ethereum og håndtere sine midler.", "page-index-get-started-wallet-image-alt": "Illustration af en robot med en bankboks som krop repræsenterende en Ethereum-tegnebog.", "page-index-get-started-eth-title": "Få ETH", "page-index-get-started-eth-description": "ETH er valutaen for Ethereum – den kan anvendes i applikationer.", @@ -19,33 +19,33 @@ "page-index-get-started-dapps-image-alt": "Illustration af en doge som bruger en computer.", "page-index-get-started-devs-title": "Begynd at udvikle", "page-index-get-started-devs-description": "Ønsker man at starte kodning med Ethereum, har vi dokumentation, vejledninger og mere i vores udviklerportal.", - "page-index-get-started-devs-image-alt": "Illustration af en hånd, der bygger en Ethereum logo af Lego-klodser.", + "page-index-get-started-devs-image-alt": "Illustration af en hånd, der bygger et Ethereum-logo af Lego-klodser.", "page-index-what-is-ethereum": "Hvad er Ethereum?", - "page-index-what-is-ethereum-description": "Ethereum er en teknologi, der er hjemsted for digitale penge, globale betalinger og applikationer. Fællesskabet har opbygget en blomstrende digital økonomi, dristige nye måder for kreatører til at tjene online, og så meget mere. Det er åbent for alle, uanset hvor man er i verden – alt hvad der behøves, er Internet.", + "page-index-what-is-ethereum-description": "Ethereum er en teknologi, der er hjemsted for digitale penge, globale betalinger og applikationer. Fællesskabet har opbygget en blomstrende digital økonomi, dristige nye måder for oprettere til at tjene online, og så meget mere. Det er åbent for alle, uanset hvor man er i verden – alt hvad der behøves, er Internet.", "page-index-what-is-ethereum-button": "Hvad er Ethereum?", "page-index-what-is-ethereum-secondary-button": "Mere om digitale penge", "page-index-what-is-ethereum-image-alt": "Illustration af en person, der kigger ind i en bazar, repræsenterende Ethereum.", "page-index-defi": "Et mere retfærdigt finansielt system", "page-index-defi-description": "I dag kan milliarder af personer ikke åbne bankkonti, andre får deres betalinger blokeret. Ethereum's decentraliserede finansielle (DeFi) system sover eller diskriminerer aldrig. Med blot en Internetforbindelse kan man sende, modtage, låne eller tjene penge og endda streame midler overalt i verden.", "page-index-defi-button": "Udforsk DeFi", - "page-index-defi-image-alt": "Illustration af hænder tilbydende et ETH-symbol.", + "page-index-defi-image-alt": "Illustration af hænder, der tilbyder et ETH-symbol.", "page-index-internet": "Et åbent Internet", - "page-index-internet-description": "'Gratis' Internettjenester tilgås i dag ved at opgive kontrollen over personlige data. Ethereum-tjenester er som standard åben – der kræves blot en tegnebog, som er gratis, nem at opsætte, kontrolleres af ejeren og fungerer uden personlige oplysninger.", + "page-index-internet-description": "'Gratis' Internettjenester tilgås i dag ved at opgive kontrollen over personlige data. Ethereum-tjenester er som standard åbne – der kræves blot en tegnebog, som er gratis, nem at opsætte, kontrolleres af ejeren og fungerer uden personlige oplysninger.", "page-index-internet-button": "Udforsk det åbne Internet", "page-index-internet-secondary-button": "Mere om tegnebøger", "page-index-internet-image-alt": "Illustration af en futuristisk computeropsætning drevet af Ethereum-krystaller.", - "page-index-developers": "En ny grænse for udvikling", - "page-index-developers-description": "Ethereum og dens apps er gennemsigtige og open-source. Man kan genbruge (fork) kode og dermed funktionalitet, som andre allerede har bygget. Ønsker man ikke at lære et nyt sprog, kan man blot interagere med open-sourced kode vha. JavaScript og andre eksisterende sprog.", + "page-index-developers": "Et nyt grænseområde for udvikling", + "page-index-developers-description": "Ethereum og dens apps er gennemsigtige og open-source. Man kan forgrene (fork) kode og dermed funktionalitet, som andre allerede har bygget. Ønsker man ikke at lære et nyt sprog, kan man blot interagere med open-sourced kode vha. JavaScript og andre eksisterende sprog.", "page-index-developers-button": "Udviklerportal", "page-index-developers-code-examples": "Kodeeksempler", "page-index-developers-code-example-title-0": "Din egen bank", "page-index-developers-code-example-description-0": "Man kan bygge en bank drevet af logik, man har kodet.", "page-index-developers-code-example-title-1": "Din egen valuta", - "page-index-developers-code-example-description-1": "Man kan oprette tokens, som kan overføres og bruges på tværs af applikationer.", + "page-index-developers-code-example-description-1": "Man kan oprette tokens, som kan overføres og bruges i forskellige applikationer.", "page-index-developers-code-example-title-2": "En JavaScript Ethereum-tegnebog", "page-index-developers-code-example-description-2": "Man kan benytte eksisterende sprog til at interagere med Ethereum og andre applikationer.", - "page-index-developers-code-example-title-3": "Et åben, tilladelsesfrit DNS", - "page-index-developers-code-example-description-3": "Man kan forestille sig eksisterende tjenester som decentraliserede, åbne applikationer.", + "page-index-developers-code-example-title-3": "En åben, tilladelsesfri DNS", + "page-index-developers-code-example-description-3": "Man kan gentænke eksisterende tjenester som decentraliserede, åbne applikationer.", "page-index-network-stats-title": "Ethereum i dag", "page-index-network-stats-subtitle": "De seneste netværksstatistikker", "page-index-network-stats-eth-price-description": "ETH-pris (USD)", @@ -53,17 +53,17 @@ "page-index-network-stats-tx-day-description": "Transaktioner i dag", "page-index-network-stats-tx-day-explainer": "Antal gennemførte transaktioner behandlet på netværket de seneste 24 timer.", "page-index-network-stats-value-defi-description": "Værdi låst i DeFi (USD)", - "page-index-network-stats-value-defi-explainer": "Mængden af penge i decentraliseret finansapplikationer (DeFi), Ethereum-digitaløkonomien.", + "page-index-network-stats-value-defi-explainer": "Mængden af penge i decentraliserede finansapplikationer (DeFi), Ethereum-digitaløkonomien.", "page-index-network-stats-nodes-description": "Nodes", "page-index-network-stats-nodes-explainer": "Ethereum drives af tusindvis af frivillige verden over, betegnet nodes.", "page-index-touts-header": "Tjek ethereum.org ud", "page-index-contribution-banner-title": "Bidrag til ethereum.org", - "page-index-contribution-banner-description": "Dette websted er open-source med hundredvis af fællesskabsbidragsydere. Her kan man foreslå indholdsredigeringer, fantastiske nye funktioner eller hjælpe medfejlretning.", + "page-index-contribution-banner-description": "Dette websted er open-source med hundredvis af fællesskabsbidragsydere. Her kan man foreslå indholdsredigeringer, fantastiske nye funktioner eller hjælpe med fejlretning.", "page-index-contribution-banner-image-alt": "Et Ethereum-logo bygget af legoklodser.", "page-index-contribution-banner-button": "Mere om bidrag", "page-index-tout-upgrades-title": "Opgrader din opgraderingsviden", - "page-index-tout-upgrades-description": "The Ethereum roadmap consists of interconnected upgrades designed to make the network more scalable, secure, and sustainable.", - "page-index-tout-upgrades-image-alt": "Illustration af en rumskib, som repræsenterer den øgede effekt efter Ethereum-opgradinger.", + "page-index-tout-upgrades-description": "Ethereums køreplan består af gensidigt afhængige opgraderinger designet til at gøre netværket mere skalerbart, sikkert og bæredygtigt.", + "page-index-tout-upgrades-image-alt": "Illustration af et rumskib, som repræsenterer den øgede effekt efter Ethereum-opgradinger.", "page-index-tout-enterprise-title": "Ethereum til virksomheder", "page-index-tout-enterprise-description": "Se, hvordan Ethereum kan åbne nye forretningsmodeller, reducere omkostninger og fremtidssikre virksomheden.", "page-index-tout-enterprise-image-alt": "Illustration af en futuristisk computer/enhed.", diff --git a/src/intl/de/page-dapps.json b/src/intl/de/page-dapps.json index ff1bfeb9a11..75b45561634 100644 --- a/src/intl/de/page-dapps.json +++ b/src/intl/de/page-dapps.json @@ -1,5 +1,6 @@ { "page-dapps-1inch-logo-alt": "1inch-Logo", + "page-dapps-dexguru-logo-alt": "DexGuru Logo", "page-dapps-aave-logo-alt": "Aave-Logo", "page-dapps-add-button": "DApp vorschlagen", "page-dapps-add-title": "DApp hinzufügen", @@ -86,6 +87,7 @@ "page-dapps-dapp-description-token-sets": "Strategien für Krypto-Investitionen, die sich automatisch ausgleichen.", "page-dapps-dapp-description-tornado-cash": "Versenden Sie anonyme Transaktionen auf Ethereum.", "page-dapps-dapp-description-uniswap": "Tauschen Sie Token einfach oder stellen Sie Token für prozentuale Vergütung zur Verfügung.", + "page-dapps-dapp-description-dexguru": "Nicht-verwahrendes Handelsterminal für DeFi-Trader", "page-dapps-docklink-dapps": "Einführung in dApps", "page-dapps-docklink-smart-contracts": "Smart Contracts", "page-dapps-dark-forest-logo-alt": "Dark-Forest-Logo", diff --git a/src/intl/de/page-languages.json b/src/intl/de/page-languages.json index 390c794d9f5..2fa9f3d639a 100644 --- a/src/intl/de/page-languages.json +++ b/src/intl/de/page-languages.json @@ -46,7 +46,8 @@ "language-ms": "Malaiisch", "language-nb": "Norwegisch", "language-nl": "Niederländisch", - "language-fil": "Filipino", + "language-pcm": "Nigerianisches Pidgin", + "language-ph": "Filipino", "language-pl": "Polnisch", "language-pt": "Portugiesisch", "language-pt-br": "Portugiesisch (Brasilien)", diff --git a/src/intl/de/page-wallets-find-wallet.json b/src/intl/de/page-wallets-find-wallet.json index 3fde0dd867b..263c34c8092 100644 --- a/src/intl/de/page-wallets-find-wallet.json +++ b/src/intl/de/page-wallets-find-wallet.json @@ -89,5 +89,6 @@ "page-find-wallet-browser": "Browser", "page-find-wallet-browser-desc": "Wallets mit Browser-Erweiterungen", "page-find-wallet-device": "Gerät", - "page-find-choose-to-compare": "Zum Vergleich auswählen" + "page-find-choose-to-compare": "Zum Vergleich auswählen", + "page-find-wallet-choose-features": "Funktionen auswählen" } diff --git a/src/intl/de/page-what-is-ethereum.json b/src/intl/de/page-what-is-ethereum.json index 4d6e667174d..0dcbf30235b 100644 --- a/src/intl/de/page-what-is-ethereum.json +++ b/src/intl/de/page-what-is-ethereum.json @@ -88,10 +88,8 @@ "page-what-is-ethereum-energy-desc-2": "Die Zusammenführung war Ethereums größte Verbesserung und reduzierte den Energieverbrauch, welcher benötigt wird, um Ethereum abzusichern, um 99,95 %, was ein sichereres Netzwerk für wesentlich geringere CO2-Emissionskosten schuf. Ethereum ist nun eine kohlenstoffarme Blockchain mit gleichzeitig erhöhter Sicherheit und Skalierbarkeit.", "page-what-is-ethereum-more-on-energy-consumption": "Mehr zum Energieverbrauch", "page-what-is-ethereum-energy-consumption-chart-legend": "Jährlicher Energieverbrauch in TWh/Jahr", - "energy-consumption-chart-youtube-label": "YouTube", - "energy-consumption-chart-gold-mining-galaxy-label": "Goldförderung (Galaxy Digital)", "energy-consumption-chart-global-data-centers-label": "Globale Rechenzentren", - "energy-consumption-chart-gold-mining-cbeci-label": "Goldabbau (CBECI)", + "energy-consumption-gold-mining-cbeci-label": "Goldabbau", "energy-consumption-chart-btc-pow-label": "BTC PoW", "energy-consumption-chart-netflix-label": "Netflix", "energy-consumption-chart-eth-pow-label": "ETH PoW", diff --git a/src/intl/en/common.json b/src/intl/en/common.json index b41572eb65a..9c058915dd0 100644 --- a/src/intl/en/common.json +++ b/src/intl/en/common.json @@ -142,6 +142,7 @@ "pools": "Pooled staking", "privacy-policy": "Privacy policy", "private-ethereum": "Private Ethereum", + "product-disclaimer": "Products and services are listed as a convenience for the Ethereum community. Inclusion of a product or service does not represent an endorsement from the ethereum.org website team, or the Ethereum Foundation.", "quizzes-title": "Quiz Hub", "quizzes": "Quizzes", "refresh": "Please refresh the page.", diff --git a/src/intl/en/page-staking.json b/src/intl/en/page-staking.json index 8e9c028a6cb..fc5727d2a3b 100644 --- a/src/intl/en/page-staking.json +++ b/src/intl/en/page-staking.json @@ -132,12 +132,12 @@ "page-staking-considerations-pools-5-description": "Service does not require trusting any humans to custody your keys or distribute rewards", "page-staking-considerations-pools-6-title": "Permissionless nodes", "page-staking-considerations-pools-6-description": "Service allows anyone to join as a node operator for the pool, without permission", - "page-staking-considerations-pools-7-description": "Service should not run more than 50% of their aggregate validators with a majority consensus client", + "page-staking-considerations-pools-7-description": "Service should not run more than 50% of their aggregate validators with a majority execution client", "page-staking-considerations-pools-8-title": "Liquidity token", "page-staking-considerations-pools-8-description": "Offers tradable liquidity token representing your staked ETH, held in your own wallet", "page-staking-considerations-pools-8-valid": "Liquidity token(s)", "page-staking-considerations-pools-8-warning": "No liquidity token", - "page-staking-considerations-pools-9-description": "Service should not run more than 50% of their aggregate validators with a majority execution client", + "page-staking-considerations-pools-9-description": "Service should not run more than 50% of their aggregate validators with a majority consensus client", "page-staking-how-solo-works-item-1": "Get some hardware: You need to run a node to stake", "page-staking-how-solo-works-item-2": "Sync an execution layer client", "page-staking-how-solo-works-item-3": "Sync a consensus layer client", diff --git a/src/intl/fil/common.json b/src/intl/fil/common.json index c4bbb5604ad..724ce2a1c1a 100644 --- a/src/intl/fil/common.json +++ b/src/intl/fil/common.json @@ -1,4 +1,5 @@ { + "account-abstraction": "Account abstraction", "about-ethereum-org": "Tungkol sa ethereum.org", "about-us": "Tungkol sa amin", "aria-toggle-search-button": "I-toggle ang button sa paghahanap", @@ -6,17 +7,20 @@ "zen-mode": "Zen Mode", "beacon-chain": "Beacon Chain", "bridges": "Mga blockchain bridge", + "clear": "I-clear", "close": "Isara", "community": "Komunidad", "community-hub": "Hub ng komunidad", "community-menu": "Menu ng Komunidad", "contact": "I-contact", + "content-standardization": "Pag-standardize ng content", "contributing": "Pagko-contribute", "contributors": "Mga Contributor", "contributors-thanks": "Sa lahat ng mga nag-ambag sa pahinang ito – Salamat sa inyo!", "cookie-policy": "Polisiya sa cookies", "copied": "Kinopya", "copy": "Kopyahin", + "danksharding": "Danksharding", "dark-mode": "Madilim", "data-provided-by": "Pinagmulan ng data:", "decentralized-applications-dapps": "Mga decentralized application (dapps)", @@ -25,7 +29,24 @@ "developers": "Mga Developer", "developers-home": "Home ng mga developer", "docs": "Mga Dokumento", + "docsearch-to-select": "Para pumili", + "docsearch-to-navigate": "Para mag-navigate", + "docsearch-to-close": "Para isara", + "docsearch-search-by": "Maghanap sa pamamagitan ng", + "docsearch-start-recent-searches-title": "Kamakailan", + "docsearch-start-no-recent-searches": "Walang kamakailang paghahanap", + "docsearch-start-save-recent-search": "I-save ang paghahanap na ito", + "docsearch-start-remove-recent-search": "Alisin ang paghahanap na ito sa history", + "docsearch-start-favorite-searches": "Paborito", + "docsearch-start-remove-favorite-search": "Alisin ang paghahanap na ito sa mga paborito", + "docsearch-no-results-text": "Walang resulta para sa", + "docsearch-no-results-suggested-query": "Subukang maghanap para sa", + "docsearch-no-results-missing": "Sa palagay mo, dapat magbalik ng mga resulta ang query na ito?", + "docsearch-no-results-missing-link": "Ipaalam ito sa amin.", + "docsearch-error-title": "Hindi makakuha ng mga resulta", + "docsearch-error-help": "Baka gusto mong tingnan ang iyong koneksyon sa network.", "documentation": "Dokumentasyon", + "down": "Pababa", "ecosystem": "Ecosystem", "edit-page": "I-edit ang pahina", "ef-blog": "Blog ng Ethereum Foundation", @@ -60,15 +81,22 @@ "feedback-widget-thank-you-timing": "2–3 min", "feedback-widget-thank-you-cta": "Buksan ang maikling survey", "find-wallet": "Maghanap ng wallet", + "future-proofing": "Pag-future proof", "get-eth": "Kumuha ng ETH", "get-involved": "Makibahagi", "get-started": "Magsimula", "grants": "Mga Grant", "grant-programs": "Mga Ecosystem Grant Program", - "guides-and-resources": "Mga gabay at resource ng komunidad", + "guides": "Mga Gabay", + "guides-hub": "Hub ng mga gabay", "history-of-ethereum": "Kasaysayan ng Ethereum", "home": "Home", "how-ethereum-works": "Paano gumagana ang Ethereum", + "how-to-register-an-ethereum-account": "Paano \"magrehistro\" ng Ethereum account", + "how-to-revoke-token-access": "Paano bawiin ang access sa smart contract sa iyong mga pondo sa crypto", + "how-to-swap-tokens": "Paano mag-swap ng mga token", + "how-to-use-a-bridge": "Paano madadala ang mga token sa layer 2", + "how-to-use-a-wallet": "Paano gumamit ng wallet", "image": "larawan", "in-this-section": "Sa seksyong ito", "individuals": "Mga indibidwal", @@ -82,6 +110,7 @@ "layer-2": "Layer 2", "learn": "Matuto", "learn-by-coding": "Matuto sa pamamagitan ng pag-code", + "learn-hub": "Learn Hub", "learn-menu": "Menu ng pag-aaral", "learn-more": "Matuto pa", "less": "Mas kaunti", @@ -96,22 +125,30 @@ "nav-developers": "Mga Developer", "nav-developers-docs": "Developers docs", "nav-primary": "Primary", + "nfts": "NFTs", "no": "Hindi", "on-this-page": "Sa page na ito", "open-research": "Open research", "page-last-updated": "Huling na-update ang page", + "pbs": "Paghihiwalay ng tagamungkahi at tagabuo", "privacy-policy": "Patakaran sa privacy", "private-ethereum": "Pribadong Ethereum", "refresh": "Paki-refresh ang pahina.", "return-home": "bumalik sa home", + "roadmap": "Roadmap ng Ethereum", "run-a-node": "Mag-run ng node", "rollup-component-website": "Website", "rollup-component-developer-docs": "Developer docs", "rollup-component-technology-and-risk-summary": "Buod ng teknolohiya at risk", + "scaling": "Pagsusukat", "search": "Maghanap", + "search-ethereum-org": "Hanapin ang ethereum.org", + "secret-leader-election": "Lihim na halalan ng pinuno", "search-box-blank-state-text": "Hanapin!", "search-eth-address": "Mukhang isang Ethereum address ito. Hindi kami nagbibigay ng data na partikular sa mga address. Subukang hanapin ito sa isang block explorer tulad ng", "search-no-results": "Walang resulta sa iyong hinahanap", + "single-slot-finality": "Pagiging pinal ng single-slot", + "statelessness": "Kawalan ng estado", "see-contributors": "Tingnan ang mga contributor", "set-up-local-env": "Mag-set up ng lokal na environment", "sharding": "Sharding", @@ -122,10 +159,13 @@ "skip-to-main-content": "Lumaktaw sa main content", "smart-contracts": "Mga smart contract", "stablecoins": "Stablecoins", + "stake-eth": "Mag-stake ng ETH", "staking": "Staking", + "style-guide": "Style guide", "solo": "Solo staking", "saas": "Staking as a service", "pools": "Pooled staking", + "withdrawals": "Mga pag-withdraw ng stake", "terms-of-use": "Mga tuntunin ng paggamit", "translation-banner-body-new": "Tinitingnan mo ang pahinang ito sa English dahil hindi pa namin ito naisalin. Tulungan kaming isalin ang nilalamang ito.", "translation-banner-body-update": "May bagong bersyon ng page na ito ngunit nasa English lang ito ngayon. Tulungan kaming isalin ang pinakabagong bersyon.", @@ -138,11 +178,15 @@ "translation-banner-no-bugs-dont-show-again": "Huwag nang ipakita ulit", "try-using-search": "Subukang gamitin ang paghahanap upang mahanap kung ano ang iyong hinahanap o", "tutorials": "Mga tutorial", + "up": "Pataas", "use-ethereum": "Gumamit ng Ethereum", "use-ethereum-menu": "Gamitin ang Ethereum menu", + "user-experience": "User experience", + "verkle-trees": "Verkle trees", "wallets": "Mga Wallet", "we-couldnt-find-that-page": "Hindi namin mahanap ang page na iyon", "web3": "Ano ang Web3?", + "web3-title": "Web3", "website-last-updated": "Huling pag-update sa website", "what-is-ether": "Ano ang ether (ETH)?", "what-is-ethereum": "Ano ang Ethereum?", @@ -153,5 +197,7 @@ "decentralized-identity": "Decentralized na identity", "yes": "Oo", "zero-knowledge-proofs": "Zero-knowledge proofs", - "page-index-meta-title": "Home" + "ethereum-roadmap": "Lalakbaying daan ng Ethereum", + "page-index-meta-title": "Home", + "page-developers-aria-label": "Developers' Menu" } diff --git a/src/intl/fr/page-languages.json b/src/intl/fr/page-languages.json index 01bd4aba5df..90b58f1b4fe 100644 --- a/src/intl/fr/page-languages.json +++ b/src/intl/fr/page-languages.json @@ -46,6 +46,7 @@ "language-ms": "Malais", "language-nb": "Norvégien", "language-nl": "Néerlandais", + "language-pcm": "Pidgin Nigérian", "language-fil": "Philippin", "language-pl": "Polonais", "language-pt": "Portugais", diff --git a/src/intl/fr/page-layer-2.json b/src/intl/fr/page-layer-2.json index de11b1ae851..8106cdd8498 100644 --- a/src/intl/fr/page-layer-2.json +++ b/src/intl/fr/page-layer-2.json @@ -30,7 +30,7 @@ "layer-2-why-do-we-need-layer-2-2": "Ethereum a atteint la capacité actuelle du réseau avec plus d'un million de transactions par jour et une forte demande pour chacune de ces transactions. Le succès d'Ethereum et la demande d'utilisation ont causé une hausse substantielle des prix du gaz. Par conséquent, le besoin de solutions de mise à l'échelle a également augmenté. C'est là que les réseaux de la couche 2 entrent en jeu.", "layer-2-why-do-we-need-layer-2-scalability": "Évolutivité", "layer-2-why-do-we-need-layer-2-scalability-1": "L'objectif principal de l'évolutivité est d'augmenter la vitesse des transactions (finalité plus rapide) et le débit des transactions (plus de transactions par seconde) sans sacrifier la décentralisation ou la sécurité.", - "layer-2-why-do-we-need-layer-2-scalability-2": "La communauté Ethereum a adopté une position ferme : elle ne sacrifiera ni la décentralisation ni la sécurité pour gagner en évolutivité. Jusqu'à l'implémentation de la fragmentation , le réseau principal Ethereum (couche 1) ne peut donc traiter qu'environ 15 transactions par seconde. Lorsque la demande d'utilisation d'Ethereum est élevée, le réseau est encombré, ce qui augmente les frais de transaction et exclut du réseau les utilisateurs qui ne peuvent pas supporter ces frais. C'est sur ce point précis que la couche 2 permettra à Ethereum d'évoluer.", + "layer-2-why-do-we-need-layer-2-scalability-2": "La communauté Ethereum a adopté une position ferme : elle ne sacrifiera ni la décentralisation ni la sécurité pour gagner en évolutivité. Jusqu'à l'implémentation de la fragmentation , le réseau principal Ethereum (couche 1) ne peut donc traiter qu'environ 15 transactions par seconde. Lorsque la demande d'utilisation d'Ethereum est élevée, le réseau est encombré, ce qui augmente les frais de transaction et exclut du réseau les utilisateurs qui ne peuvent pas supporter ces frais. C'est sur ce point précis que la couche 2 permettra à Ethereum d'évoluer.", "layer-2-why-do-we-need-layer-2-scalability-3": "En savoir plus sur la vision d'Ethereum", "layer-2-benefits-of-layer-2-title": "Les avantages de la couche 2", "layer-2-lower-fees-title": "Des frais plus bas", diff --git a/src/intl/fr/page-wallets-find-wallet.json b/src/intl/fr/page-wallets-find-wallet.json index 935bec891fa..d6c0ac77870 100644 --- a/src/intl/fr/page-wallets-find-wallet.json +++ b/src/intl/fr/page-wallets-find-wallet.json @@ -89,5 +89,6 @@ "page-find-wallet-browser": "Navigateur", "page-find-wallet-browser-desc": "Portefeuilles avec extensions pour navigateur", "page-find-wallet-device": "Appareil", - "page-find-choose-to-compare": "Choisir pour comparer" + "page-find-choose-to-compare": "Choisir pour comparer", + "page-find-wallet-choose-features": "Choisir des fonctionnalités" } diff --git a/src/intl/fr/page-what-is-ethereum.json b/src/intl/fr/page-what-is-ethereum.json index 848b21854e9..b0ab4460b99 100644 --- a/src/intl/fr/page-what-is-ethereum.json +++ b/src/intl/fr/page-what-is-ethereum.json @@ -88,10 +88,8 @@ "page-what-is-ethereum-energy-desc-2": "La Fusion a été la plus grande mise à jour d'Ethereum et a réduit la consommation d'énergie nécessaire pour sécuriser Ethereum de 99,5 %, créant ainsi un réseau plus sécurisé pour un coût carbone sensiblement réduit. Ethereum est maintenant une blockchain à faible émission de carbone et à sécurité et évolutivité renforcées.", "page-what-is-ethereum-more-on-energy-consumption": "En savoir plus sur la consommation d'énergie", "page-what-is-ethereum-energy-consumption-chart-legend": "Consommation d'énergie annuelle en TWh/an", - "energy-consumption-chart-youtube-label": "YouTube", - "energy-consumption-chart-gold-mining-galaxy-label": "Extraction d'or (Galaxy Digital)", "energy-consumption-chart-global-data-centers-label": "Centres de données globaux", - "energy-consumption-chart-gold-mining-cbeci-label": "Extraction d'or (CBECI)", + "energy-consumption-gold-mining-cbeci-label": "Extraction d'or", "energy-consumption-chart-btc-pow-label": "BTC PoW", "energy-consumption-chart-netflix-label": "Netflix", "energy-consumption-chart-eth-pow-label": "ETH PoW", diff --git a/src/intl/it/learn-quizzes.json b/src/intl/it/learn-quizzes.json index 8b0b1d68717..5f7f6d391ff 100644 --- a/src/intl/it/learn-quizzes.json +++ b/src/intl/it/learn-quizzes.json @@ -1,3 +1,312 @@ { - "page-assets-merge": "La Fusione" + "correct": "Corretto", + "explanation": "Spiegazione", + "next-question": "Prossima domanda", + "score": "Punteggio", + "see-results": "Visualizza i risultati", + "share-results": "Condividi i risultati", + "submit-answer": "Invia risposta", + "test-your-knowledge": "Metti alla prova le tue conoscenze", + "total": "Totale", + "try-again": "Riprova", + "a001-prompt": "La principale differenza tra Ethereum e Bitcoin è:", + "a001-a-label": "Ethereum non ti consente di inviare pagamenti ad altre persone", + "a001-a-explanation": "Sia Bitcoin che Ethereum ti consentono di inviare pagamenti ad altre persone.", + "a001-b-label": "Puoi eseguire programmi informatici su Ethereum", + "a001-b-explanation": "Ethereum è programmabile. Ciò significa che puoi inserire qualsiasi programma sulla blockchain di Ethereum.", + "a001-c-label": "Puoi eseguire programmi informatici su Bitcoin", + "a001-c-explanation": "A differenza di Ethereum, Bitcoin non è programmabile e non può eseguire programmi informatici arbitrari.", + "a001-d-label": "Hanno loghi differenti", + "a001-d-explanation": "Hanno loghi differenti! Ma non è la principale differenza tra i due.", + "a002-prompt": "La criptovaluta nativa di Ethereum si chiama:", + "a002-a-label": "Ether", + "a002-a-explanation": "Ether è la criptovaluta nativa della rete di Ethereum.", + "a002-b-label": "Ethereum", + "a002-b-explanation": "Ethereum è la blockchain, ma la sua valuta nativa non si chiama Ethereum. Questo è un equivoco comune.", + "a002-c-label": "Ethercoin", + "a002-c-explanation": "A differenza di molte altre criptovalute, la criptovaluta nativa di Ethereum non contiene la parola 'coin'.", + "a002-d-label": "Bitcoin", + "a002-d-explanation": "Bitcoin (B maiuscola) è stata la prima blockchain creata, bitcoin (B minuscola) è la sua criptovaluta nativa.", + "a003-prompt": "Chi controlla Ethereum?", + "a003-a-label": "Sviluppatori", + "a003-a-explanation": "Gli sviluppatori sono fondamentali per costruire e migliorare Ethereum, ma non sono il gruppo che mantiene in funzione Ethereum.", + "a003-b-label": "Miner", + "a003-b-explanation": "Il mining non è più possibile dalla Fusione. Non ci sono più 'miner' su Ethereum.", + "a003-c-label": "La Ethereum Foundation", + "a003-c-explanation": "La Ethereum Foundation non svolge alcun ruolo significativo nell'esecuzione quotidiana dei nodi di Ethereum.", + "a003-d-label": "Chiunque esegua un nodo", + "a003-d-explanation": "Chiunque esegua un nodo è una parte fondamentale dell'infrastruttura di Ethereum. Se non lo hai già fatto, valuta di eseguirne uno.", + "a004-prompt": "Dal lancio di Ethereum, quante volte è andata offline la sua rete?", + "a004-a-label": "Mai", + "a004-b-label": "Una volta", + "a004-c-label": "Quattro volte", + "a004-d-label": "Più di dieci volte", + "a004-explanation": "Ethereum non è mai andata offline dal suo lancio.", + "a005-prompt": "Ethereum consuma più elettricità di:", + "a005-a-label": "YouTube", + "a005-a-explanation": "YouTube utilizza approssimativamente 244 Terawatt all'anno. Ethereum consuma 0,01 Terawatt all'anno.", + "a005-b-label": "Netflix", + "a005-b-explanation": "Netflix utilizza approssimativamente 94 Terawatt all'anno. Ethereum consuma 0,01 Terawatt all'anno.", + "a005-c-label": "PayPal", + "a005-c-explanation": "PayPal utilizza approssimativamente 0,26 Terawatt all'anno. Ethereum consuma 0,01 Terawatt all'anno.", + "a005-d-label": "Nessuna delle precedenti", + "a005-d-explanation": "Ethereum utilizza 0,01 Terawatt all'anno. Meno di YouTube (circa 244 TW/anno), Netfliix (circa 94 TW/anno) e PayPal (circa 0,26 TW/anno).", + "b001-prompt": "Ether è anche noto come:", + "b001-a-label": "ETC", + "b001-a-explanation": "ETC è il simbolo di Ethereum Classic.", + "b001-b-label": "ETR", + "b001-b-explanation": "ETR non è un simbolo di ether o di qualsiasi altra criptovaluta significativa.", + "b001-c-label": "ETH", + "b001-c-explanation": "ETH è il simbolo di ether su Ethereum.", + "b001-d-label": "BTC", + "b001-d-explanation": "BTC è il simbolo di bitcoin sulla rete di Bitcoin.", + "b002-prompt": "Su Ethereum, le commissioni di rete sono pagate in:", + "b002-a-label": "bitcoin", + "b002-a-explanation": "\"bitcoin\" in minuscolo è la criptovaluta nativa della rete di Bitcoin.", + "b002-b-label": "ETH", + "b002-b-explanation": "Ether (ETH) è la criptovaluta nativa di Ethereum. Tutte le commissioni di rete su Ethereum sono pagate in ETH.", + "b002-c-label": "USD", + "b002-c-explanation": "Non è possibile pagare le commissioni di rete su Ethereum in USD (dollari statunitense), o qualsiasi altra valuta legale.", + "b002-d-label": "R/Ethereum", + "b002-d-explanation": "Ethereum è la rete, ma le commissioni di rete di Ethereum sono pagate in ETH.", + "b003-prompt": "Lo staking su Ethereum aiuta a proteggere la rete perché:", + "b003-a-label": "Gli staker possono bandire le persone se non gli piace ciò che stanno facendo", + "b003-a-explanation": "Gli staker non possono censurare arbitrariamente gli utenti.", + "b003-b-label": "Se uno staker prova a imbrogliare la rete, rischia di perdere i propri ETH", + "b003-b-explanation": "Gli staker rischiano di perdere significativi importi di ETH se si comportano in modo malevolo contro la rete. Ciò è noto come taglio.", + "b003-c-label": "Gli staker utilizzano computer potenti per dimostrare il proof-of-work", + "b003-c-explanation": "Gli staker non necessitano di potenti hardware per mettere i propri ETH in staking. Ethereum ha smesso di utilizzare il proof-of-work alla Fusione.", + "b003-d-label": "Gli staker subiscono KYC prima di essere accettati come validatori", + "b003-d-explanation": "Lo staking su Ethereum è senza autorizzazioni e non richiede KYC.", + "b004-prompt": "ETH è prezioso perché:", + "b004-a-label": "ETH è necessario per fare qualsiasi cosa su Ethereum", + "b004-a-explanation": "Questa risposta è parzialmente corretta, ma è solo una delle motivazioni per cui gli ETH sono preziosi.", + "b004-b-label": "ETH è una valuta peer-to-peer incensurabile", + "b004-b-explanation": "Questa risposta è parzialmente corretta, ma è solo una delle motivazioni per cui gli ETH sono preziosi.", + "b004-c-label": "ETH è usato come garanzia per i prestiti di criptovalute", + "b004-c-explanation": "Questa risposta è parzialmente corretta, ma è solo una delle motivazioni per cui gli ETH sono preziosi.", + "b004-d-label": "Tutte le precedenti", + "b004-d-explanation": "Le transazioni su Ethereum sono censurabili, gli ETH sono necessari per effettuare qualsiasi transazione su Ethereum e sono fondamentali per la stabilità dell'ecosistema della DeFi.", + "c001-prompt": "Il Web3 consente agli utenti di possedere risorse digitali direttamente, tramite:", + "c001-a-label": "DAO", + "c001-a-explanation": "Le DAO (organizzazioni autonome decentralizzate) sono comunità di proprietà dei membri prive di una leadership centralizzata.", + "c001-b-label": "NFT", + "c001-b-explanation": "I NFT (token non fungibili) forniscono un modo per rappresentare qualsiasi cosa unica come una risorsa basata su Ethereum.", + "c001-c-label": "ENS", + "c001-c-explanation": "L'ENS (Ethereum Name Service) è un servizio di denominazione decentralizzata per la blockchain di Ethereum.", + "c001-d-label": "GitHub", + "c001-d-explanation": "GitHub è una piattaforma centralizzata atta principalmente a memorizzare il codice utilizzando il controllo della versione distribuita. GitHub non consente la proprietà dei tuoi dati o delle risorse digitali.", + "c002-prompt": "Web1 era di sola lettura, Web2 è di lettura e scrittura, Web3 è stato descritto come:", + "c002-a-label": "di lettura, scrittura e vendita", + "c002-a-explanation": "Web3 non è stato descritto così.", + "c002-b-label": "di lettura, scrittura e archiviazione", + "c002-b-explanation": "Web3 non è stato descritto così.", + "c002-c-label": "di lettura, scrittura e proprietà", + "c002-c-explanation": "Web3 consente agli utenti di possedere i propri dati e, dunque, è stato descritto come di 'lettura, scrittura e proprietà', un miglioramento al rispetto al Web2, che è solo di 'lettura e scrittura'.", + "c002-d-label": "di lettura, scrittura e acquisto", + "c002-d-explanation": "Web3 non è stato descritto così.", + "c003-prompt": "Quale interazione del web non si affida a fornitori di pagamento di terze parti?", + "c003-a-label": "Web1", + "c003-a-explanation": "Web1 non aveva pagamenti nativi incorporati.", + "c003-b-label": "Web2", + "c003-b-explanation": "Web2 non ha pagamenti nativi incorporati.", + "c003-c-label": "Web3", + "c003-c-explanation": "Web3 prevede pagamenti nativi incorporati con le criptovalute, come ETH.", + "c003-d-label": "Tutte le precedenti", + "c003-d-explanation": "Web1 e Web2 non hanno pagamenti nativi incorporati.", + "c004-prompt": "Il termine 'Web3' è stato coniato da:", + "c004-a-label": "Gavin Wood", + "c004-a-explanation": "Gavin Wood, un co-fondatore di Ethereum, è stato accreditato per aver coniato il termine Web3 poco dopo il lancio di Ethereum nel 2015.", + "c004-b-label": "Steve Jobs", + "c004-b-explanation": "Steve Jobs non ha coniato il termine 'Web3'.", + "c004-c-label": "Vitalik Buterin", + "c004-c-explanation": "Vitalik Buterin, pur essendo il fondatore originale di Ethereum, non ha coniato il termine 'Web3'.", + "c004-d-label": "Elon Musk", + "c004-d-explanation": "Elon Musk non ha coniato il termine 'Web3'.", + "c005-prompt": "Puoi avere un unico accesso resistente alla censura in tutto il web utilizzando:", + "c005-a-label": "Accesso con Facebook", + "c005-a-explanation": "L'Accesso con Facebook non è resistente alla censura.", + "c005-b-label": "Accesso con Google", + "c005-b-explanation": "L'Accesso con Google non è resistente alla censura.", + "c005-c-label": "Accesso con Ethereum", + "c005-c-explanation": "L'Accesso con Ethereum è l'unica opzione resistente alla censura ed è utilizzabile su qualsiasi applicazione web.", + "c005-d-label": "Accesso con Twitter", + "c005-d-explanation": "L'Accesso con Twitter non è resistente alla censura.", + "d001-prompt": "Il tipo di portafoglio più sicuro è:", + "d001-a-label": "Un portafoglio mobile", + "d001-a-explanation": "I portafogli mobili detengono le chiavi private su un dispositivo mobile che, tipicamente, ha connessioni a Internet e potrebbe esser compromesso da altri software.", + "d001-b-label": "Un portafoglio hardware", + "d001-b-explanation": "Le chiavi private di un portafoglio hardware sono memorizzate su un dispositivo dedicato che può essere tenuto isolato da Internet e dalle altre applicazioni sui tuoi dispositivi.", + "d001-c-label": "Un portafoglio web", + "d001-c-explanation": "I portafogli web sono meno sicuri dei portafogli hardware poiché le chiavi private sono memorizzate su un dispositivo connesso a Internet.", + "d001-d-label": "Un portafoglio desktop", + "d001-d-explanation": "I portafogli desktop detengono le chiavi private sul disco rigido di un computer che, tipicamente, ha connessioni a Internet e potrebbe essere compromesso da altri software.", + "d002-prompt": "Tra le opzioni presentate, qual è il metodo più sicuro per memorizzare la tua frase di seed?", + "d002-a-label": "In una foto sul tuo telefono", + "d002-a-explanation": "Questa non è l'opzione più sicura. Se questa foto è caricata su un'archiviazione in cloud, un hacker potrebbe ottenerla e accedere al tuo conto.", + "d002-b-label": "In un file sul tuo computer", + "d002-b-explanation": "Questa non è l'opzione più sicura. Gli hacker cercano sempre più spesso le informazioni relative a criptovalute sui dispositivi di destinazione. Se un hacker accede al file contenente la tua frase di seed otterrà l'accesso al tuo conto.", + "d002-c-label": "Scritta su carta", + "d002-c-explanation": "Delle opzioni disponibili, annotare la tua frase di seed su carta è la più sicura.", + "d002-d-label": "In un messaggio di testo a un membro fidato della famiglia", + "d002-d-explanation": "Non dovresti mai inviare la tua frase di seed in un messaggio a qualcuno. Il messaggio potrebbe essere intercettato da una terza parte e, anche se ti fidi assolutamente di questa persona, non sai chi potrebbe accedere al suo telefono.", + "d003-prompt": "A chi dovresti dare la tua frase di seed / le tue chiavi private?", + "d003-a-label": "Qualcuno che stai pagando", + "d003-a-explanation": "Non dovresti mai dare la tua frase di seed o le tue chiavi private a nessuno. Invece, invia i token all'indirizzo del loro portafoglio tramite una transazione.", + "d003-b-label": "Per accedere a una dapp o a un portafoglio", + "d003-b-explanation": "Non dovresti mai dare la tua frase di seed o le tue chiavi private per accedere al tuo portafoglio o alla tua dapp.", + "d003-c-label": "Staff di supporto", + "d003-c-explanation": "Non dovresti mai dare la tua frase di seed o le tue chiavi private a nessuno che affermi di essere parte dello staff di supporto. Chiunque te lo chieda è un truffatore.", + "d003-d-label": "A nessuno", + "d003-d-explanation": "Idealmente, non dovresti mai dare a nessuno la tua frase di seed o le tue chiavi private. Se ti fidi completamente di qualcuno dandogli l'accesso assoluto ai tuoi fondi (come il/la coniuge), potresti decidere di condividere tali informazioni con questa persona.", + "d004-prompt": "Un portafoglio e un conto su Ethereum sono la stessa cosa.", + "d004-a-label": "Vero", + "d004-a-explanation": "Un portafoglio è un'interfaccia visiva utilizzata per interagire con un conto di Ethereum.", + "d004-b-label": "Falso", + "d004-b-explanation": "Un portafoglio è un'interfaccia visiva utilizzata per interagire con un conto di Ethereum.", + "e001-prompt": "Perché dovresti utilizzare delle password univoche per tutti i tuoi conti?", + "e001-a-label": "Nel caso in cui una delle piattaforme subisca una violazione dei dati", + "e001-a-explanation": "Questa risposta è corretta, ma ci sono anche altre risposte corrette.", + "e001-b-label": "Nel caso in cui qualcuno alle tue spalle scopra la tua password", + "e001-b-explanation": "Questa risposta è corretta, ma ci sono anche altre risposte corrette.", + "e001-c-label": "Nel caso in cui un malware, come un key-logger, rubi la tua password", + "e001-c-explanation": "Questa risposta è corretta, ma ci sono anche altre risposte corrette.", + "e001-d-label": "Tutte le precedenti", + "e001-d-explanation": "Tutte le risposte sono corrette. Utilizzare password univoche è il metodo migliore per impedire a chiunque altro di accedere al tuo conto.", + "e002-prompt": "In seguito alla Fusione, gli ETH devono essere aggiornati in ETH2.", + "e002-a-label": "Vero", + "e002-a-explanation": "Non devi aggiornare i tuoi ETH in ETH2. Gli ETH2 non esistono e questa è una narrativa comune utilizzata dai truffatori.", + "e002-b-label": "Falso", + "e002-b-explanation": "Non devi aggiornare i tuoi ETH in ETH2. Gli ETH2 non esistono e questa è una narrativa comune utilizzata dai truffatori.", + "e003-prompt": "I giveaway di ETH sono:", + "e003-a-label": "Un ottimo modo per ottenere altri ETH", + "e003-a-explanation": "I giveaway di ETH sono truffe progettate per rubare i tuoi ETH e altri token. Non sono mai un buon modo per ricevere altri ETH.", + "e003-b-label": "Sempre autentici", + "e003-b-explanation": "I giveaway di ETH non sono mai autentici.", + "e003-c-label": "Comunemente eseguiti da membri di spicco della community", + "e003-c-explanation": "I membri di spicco della community non effettuano giveaway di ETH. I truffatori fingono che degli individui ben noti, come Elon Musk, stiano effettuando giveaway per dare alla propria truffa un senso di legittimità.", + "e003-d-label": "Sono molto probabilmente truffe", + "e003-d-explanation": "I giveaway di ETH sono sempre truffe. Segnalare e ignorare i truffatori è la cosa migliore da fare.", + "e004-prompt": "Le transazioni di Ethereum sono reversibili.", + "e004-a-label": "Vero", + "e004-a-explanation": "Le transazioni di Ethereum non sono reversibili. Chiunque ti dica altrimenti sta forse provando a truffarti.", + "e004-b-label": "Falso", + "e004-b-explanation": "Le transazioni di Ethereum non sono reversibili. Chiunque ti dica altrimenti sta forse provando a truffarti.", + "f001-prompt": "Gli NFT sono definiti in modo più esaustivo come:", + "f001-a-label": "risorse digitali univoche", + "f001-a-explanation": "Gli NFT rappresentano una risorsa digitale univoca.", + "f001-b-label": "opere d'arte digitali", + "f001-b-explanation": "Gli NFT rappresentano una risorsa digitale univoca, comunemente un'opera d'arte digitale, ma non si limitano all'arte.", + "f001-c-label": "biglietti per eventi esclusivi", + "f001-c-explanation": "Gli NFT rappresentano una risorsa digitale univoca, come un sistema di biglietteria, ma non si limita ai biglietti.", + "f001-d-label": "contratti giuridicamente vincolanti", + "f001-d-explanation": "Sebbene un contratto potrebbe rappresentare un NFT, gli NFT non sono appannaggio esclusivo dei contratti giuridicamente vincolanti.", + "f002-prompt": "Due NFT che rappresentano la stessa opera d'arte sono la stessa cosa.", + "f002-a-label": "Vero", + "f002-a-explanation": "Gli NFT sono non fungibili. Ciò significa che anche se rappresentano una stessa opera d'arte digitale, sono comunque identificabili univocamente. Nel mondo artistico tradizionale potrebbero somigliare a originali e ristampe.", + "f002-b-label": "Falso", + "f002-b-explanation": "Gli NFT sono non fungibili. Ciò significa che anche se rappresentano una stessa opera d'arte digitale, sono comunque identificabili univocamente. Nel mondo artistico tradizionale potrebbero somigliare a originali e ristampe.", + "f003-prompt": "Gli NFT rappresentano comunemente:", + "f003-a-label": "La password per il tuo portafoglio", + "f003-a-explanation": "Questo è un rischio di sicurezza e, in generale, una cattiva idea!", + "f003-b-label": "Proprietà di un oggetto digitale univoco", + "f003-b-explanation": "Gli NFT rappresentano comunemente la proprietà di un oggetto digitale univoco.", + "f003-c-label": "Il tuo saldo di ETH corrente", + "f003-c-explanation": "Gli NFT non possono rappresentare arbitrariamente il tuo saldo di ETH.", + "f003-d-label": "Tutte le precedenti", + "f003-d-explanation": "Gli NFT rappresentano comunemente la proprietà di un oggetto digitale univoco, non i saldi di ETH o le password del portafoglio.", + "f004-prompt": "Gli NFT hanno aiutato a creare una nuova:", + "f004-a-label": "economia per i curatori", + "f004-a-explanation": "Gli NFT hanno aiutato a creare una nuova economia per i creatori, non per i curatori.", + "f004-b-label": "economia carbonica", + "f004-b-explanation": "Gli NFT hanno aiutato a creare una nuova economia per i creatori, non carbonica.", + "f004-c-label": "economia per i creatori", + "f004-c-explanation": "Gli NFT hanno aiutato a creare una nuova economia per i creatori.", + "f004-d-label": "economia per i dogi", + "f004-d-explanation": "Gli NFT hanno aiutato a creare una nuova economia per i creatori, non per i dogi 🐶.", + "f005-prompt": "Gli NFT su Ethereum sono dannosi per l'ambiente", + "f005-a-label": "Vero", + "f005-a-explanation": "Dalla Fusione (transizione al proof-of-stake), qualsiasi transazione ha avuto un impatto trascurabile sull'ambiente.", + "f005-b-label": "Falso", + "f005-b-explanation": "Dalla Fusione (transizione al proof-of-stake), qualsiasi transazione ha avuto un impatto trascurabile sull'ambiente.", + "g001-prompt": "Le reti della blockchain di livello 2 servono a:", + "g001-a-label": "Ridimensionare Ethereum", + "g001-a-explanation": "Lo scopo principale dei rollup e di altre soluzioni di livello 2 è ridimensionare Ethereum.", + "g001-b-label": "Effettuare pagamenti", + "g001-b-explanation": "Lo scopo principale dei rollup e di altre soluzioni di livello 2 è ridimensionare Ethereum.", + "g001-c-label": "Acquistare NFT", + "g001-c-explanation": "Lo scopo principale dei rollup e di altre soluzioni di livello 2 è ridimensionare Ethereum.", + "g001-d-label": "Decentralizzare Ethereum", + "g001-d-explanation": "Lo scopo principale dei rollup e di altre soluzioni di livello 2 è ridimensionare Ethereum.", + "g002-prompt": "Ai fini del ridimensionamento, le reti di livello 1 più alternative si sono principalmente sacrificate in termini di:", + "g002-a-label": "Sicurezza", + "g002-a-explanation": "Le reti di Livello 1 più alternative sacrificano la sicurezza e qualcos'altro a favore del ridimensionamento.", + "g002-b-label": "Decentralizzazione", + "g002-b-explanation": "Le reti di Livello 1 più alternative sacrificano la decentralizzazione e qualcos'altro a favore del ridimensionamento.", + "g002-c-label": "Prezzo dei token", + "g002-c-explanation": "Il prezzo dei token non inficia la capacità di ridimensionamento.", + "g002-d-label": "Sicurezza e decentralizzazione", + "g002-d-explanation": "Le reti di Livello 1 più alternative sacrificano la sicurezza e la decentralizzazione per consentire il ridimensionamento.", + "g003-prompt": "Quali delle seguenti soluzioni non sono considerate di livello 2?", + "g003-a-label": "Validium", + "g003-a-explanation": "I Validium non sono considerati soluzioni di livello 2 poiché non derivano la sicurezza o la disponibilità dei dati da Ethereum", + "g003-b-label": "Catene secondarie", + "g003-b-explanation": "Le sidechain non sono considerate soluzioni di livello 2 poiché non derivano la sicurezza o la disponibilità dei dati da Ethereum.", + "g003-c-label": "Blockchain di livello 1 alternative", + "g003-c-explanation": "Le blockchain di livello 1 alternative non sono considerate soluzioni di livello 2.", + "g003-d-label": "Tutte le precedenti", + "g003-d-explanation": "Validium, sidechain e blockchain di livello 1 alternative non sono considerate soluzioni di livello 2 poiché non derivano la sicurezza o la disponibilità dei dati da Ethereum.", + "g004-prompt": "Perché Ethereum non ha un livello 2 'ufficiale'?", + "g004-a-label": "Gli sviluppatori principali sono troppo impegnati a lavorare a Ethereum", + "g004-a-explanation": "Non ci sono piani per un livello 2 'ufficiale' su Ethereum poiché trarremo vantaggio da un'ampia varietà di approcci per la progettazione di soluzioni di livello 2.", + "g004-b-label": "Come L1, alla fine Ethereum raggiungerà un proprio ridimensionamento di massa", + "g004-b-explanation": "Non ci sono piani per un livello 2 'ufficiale' su Ethereum poiché trarremo vantaggio da un'ampia varietà di approcci per la progettazione di soluzioni di livello 2.", + "g004-c-label": "Gli sviluppatori principali stanno ancora discutendo tra rollup ottimistici e zk", + "g004-c-explanation": "Non ci sono piani per un livello 2 'ufficiale' su Ethereum poiché trarremo vantaggio da un'ampia varietà di approcci per la progettazione di soluzioni di livello 2.", + "g004-d-label": "Ethereum trarrà vantaggio da un'ampia varietà di approcci per la progettazione di un L2", + "g004-d-explanation": "Non ci sono piani per un livello 2 'ufficiale' su Ethereum poiché trarremo vantaggio da un'ampia varietà di approcci per la progettazione di soluzioni di livello 2.", + "h001-prompt": "La Fusione ha spostato Ethereum su quale meccanismo di consenso?", + "h001-a-label": "Proof of Work", + "h001-a-explanation": "Il proof-of-work era il meccanismo di consenso utilizzato prima della Fusione.", + "h001-b-label": "Proof of Stake", + "h001-b-explanation": "Corretto! La Fusione ha spostato Ethereum al proof-of-stake.", + "h001-c-label": "Proof of Authority", + "h001-c-explanation": "Ethereum non utilizza e mai utilizzerà il proof-of-authority sulla Rete Principale di Ethereum.", + "h001-d-label": "Tutte le precedenti", + "h001-d-explanation": "Non sarebbe possibile, per Ethereum, disporre di tutti questi meccanismi di consenso in una volta.", + "h002-prompt": "La Fusione ha ridotto il consumo energetico di Ethereum del:", + "h002-a-label": "50%", + "h002-a-explanation": "Il consumo energetico di Ethereum è stato ridotto del 99,95% dopo che La Fusione ha consentito la transizione dal proof-of-work al proof-of-stake.", + "h002-b-label": "62,5%", + "h002-b-explanation": "Il consumo energetico di Ethereum è stato ridotto del 99,95% dopo che La Fusione ha consentito la transizione dal proof-of-work al proof-of-stake.", + "h002-c-label": "90%", + "h002-c-explanation": "Il consumo energetico di Ethereum è stato ridotto del 99,95% dopo che La Fusione ha consentito la transizione dal proof-of-work al proof-of-stake.", + "h002-d-label": "99,95%", + "h002-d-explanation": "Il consumo energetico di Ethereum è stato ridotto del 99,95% dopo che La Fusione ha consentito la transizione dal proof-of-work al proof-of-stake.", + "h003-prompt": "Quando si è verificata La Fusione?", + "h003-a-label": "15 settembre 2022", + "h003-a-explanation": "La Fusione si è verificata il 15 settembre 2022 alle 06:42:42 (UTC).", + "h003-b-label": "1 dicembre 2021", + "h003-b-explanation": "La Fusione si è verificata più tardi. L'1 dicembre 2022 è stata lanciata la Beacon Chain.", + "h003-c-label": "27 novembre 2013", + "h003-c-explanation": "La Fusione si è verificata più tardi. Il 27 novembre 2013 è stato rilasciato il whitepaper di Ethereum.", + "h003-d-label": "31 ottobre 2008", + "h003-d-explanation": "La Fusione si è verificata più tardi. Il 31 ottobre è il giorno di rilascio del Whitepaper di Bitcoin.", + "h004-prompt": "La Fusione ha comportato che gli utenti abbiano dovuto scambiare i propri ETH per ETH2:", + "h004-a-label": "Vero", + "h004-a-explanation": "ETH non è cambiato in alcun momento prima, durante o dopo La Fusione. L'idea di 'aggiornare' gli ETH in ETH2 era una tattica comune utilizzata dagli utenti malevoli per truffare altri utenti.", + "h004-b-label": "Falso", + "h004-b-explanation": "ETH non è cambiato in alcun momento prima, durante o dopo La Fusione. L'idea di 'aggiornare' gli ETH in ETH2 era una tattica comune utilizzata dagli utenti malevoli per truffare altri utenti.", + "h005-prompt": "Il livello di consenso di Ethereum era precedentemente noto come:", + "h005-a-label": "Proof of Work", + "h005-a-explanation": "Il proof-of-work era il meccanismo di consenso utilizzato prima della Fusione.", + "h005-b-label": "Eth2", + "h005-b-explanation": "Prima di essere rinominato livello di consenso, era originariamente chiamato 'Eth2'.", + "h005-c-label": "Eth1", + "h005-c-explanation": "Eth1 era il nome originale dato al livello di esecuzione, non al livello del consenso.", + "h005-d-label": "Staking", + "h005-d-explanation": "Lo staking consiste nel depositare ETH in un contratto intelligente, per aiutare a proteggere la catena.", + "page-assets-merge": "La fusione", + "security": "Sicurezza", + "page-what-is-ethereum-what-is-ether": "Cos'è un ether?" } diff --git a/src/intl/it/page-about.json b/src/intl/it/page-about.json index c6039f27fdb..e93fb395545 100644 --- a/src/intl/it/page-about.json +++ b/src/intl/it/page-about.json @@ -24,10 +24,8 @@ "page-about-p-8": "Hai un'idea su come migliorare ethereum.org? Ci piacerebbe collaborare con te!", "page-what-is-ethereum-energy-consumption-chart-legend": "Consumo di energia annuale in TWh/anno", "page-upgrades-post-merge-banner-governance-ood": "Alcuni contenuti su questa pagina sono obsoleti dopo La Fusione. Sei pregato di effettuare una PR, se vorresti contribuire.", - "energy-consumption-chart-youtube-label": "YouTube", - "energy-consumption-chart-gold-mining-galaxy-label": "Gold mining (Galaxy Digital)", "energy-consumption-chart-global-data-centers-label": "Centri elaborazione dati globali", - "energy-consumption-chart-gold-mining-cbeci-label": "Gold mining (CBECI)", + "energy-consumption-gold-mining-cbeci-label": "Estrazione dell'oro", "energy-consumption-chart-btc-pow-label": "BTC PoW", "energy-consumption-chart-netflix-label": "Netflix", "energy-consumption-chart-eth-pow-label": "ETH PoW", diff --git a/src/intl/it/page-dapps.json b/src/intl/it/page-dapps.json index d9c713ce983..33ce6721cab 100644 --- a/src/intl/it/page-dapps.json +++ b/src/intl/it/page-dapps.json @@ -1,95 +1,97 @@ { - "page-dapps-1inch-logo-alt": "Logo 1inch", - "page-dapps-aave-logo-alt": "Logo Aave", + "page-dapps-1inch-logo-alt": "Logo di 1inch", + "page-dapps-dexguru-logo-alt": "Logo di DexGuru", + "page-dapps-aave-logo-alt": "Logo di Aave", "page-dapps-add-button": "Suggerisci dapp", "page-dapps-add-title": "Aggiungi dapp", - "page-dapps-audius-logo-alt": "Logo Audius", - "page-dapps-augur-logo-alt": "Logo Augur", - "page-dapps-axie-infinity-logo-alt": "Logo Axie Infinity", + "page-dapps-audius-logo-alt": "Logo di Audius", + "page-dapps-augur-logo-alt": "Logo di Augur", + "page-dapps-axie-infinity-logo-alt": "Logo di Axie Infinity", "page-dapps-balancer-logo-alt": "Logo di Balancer", - "page-dapps-brave-logo-alt": "Logo Brave", + "page-dapps-brave-logo-alt": "Logo di Brave", "page-dapps-category-arts": "Arte e moda", "page-dapps-category-browsers": "Browser", - "page-dapps-category-collectibles": "Articoli da collezione digitali", + "page-dapps-category-collectibles": "Oggetti da collezione digitali", "page-dapps-category-competitive": "Competizione", "page-dapps-category-computing": "Strumenti di sviluppo", - "page-dapps-category-dex": "Scambio di token", + "page-dapps-category-dex": "Scambi di token", "page-dapps-category-investments": "Investimenti", - "page-dapps-category-lending": "Prestiti", + "page-dapps-category-lending": "Assunzione ed erogazione di prestiti", "page-dapps-category-lottery": "Crowdfunding", "page-dapps-category-marketplaces": "Marketplace", "page-dapps-category-music": "Musica", "page-dapps-category-payments": "Pagamenti", - "page-dapps-category-insurance": "Assicurazione", - "page-dapps-category-portfolios": "Portafogli", + "page-dapps-category-insurance": "Assicurazioni", + "page-dapps-category-portfolios": "Portfolio", "page-dapps-category-trading": "Mercati di scambio e previsione", "page-dapps-category-utilities": "Utilità", "page-dapps-category-worlds": "Mondi virtuali", "page-dapps-choose-category": "Scegli una categoria", - "page-dapps-collectibles-benefits-1-description": "Quando un'opera d'arte viene tokenizzata su Ethereum, la proprietà può essere dimostrata da chiunque. Puoi tracciare il percorso dell'opera dalla creazione all'attuale proprietario. Questo previene le falsificazioni.", + "page-dapps-collectibles-benefits-1-description": "Quando l'arte è tokenizzata su Ethereum, la proprietà è dimostrabile da chiunque. Puoi monitorare il percorso dell'opera d'arte dalla sua creazione, al suo proprietario attuale. Ciò previene le falsificazioni.", "page-dapps-collectibles-benefits-1-title": "La proprietà è dimostrabile", - "page-dapps-collectibles-benefits-2-description": "Pagare per riprodurre musica in streaming o acquistare opere d'arte è decisamente più giusto nei confronti degli artisti. Con Ethereum c'è meno bisogno di intermediari. E se gli intermediari sono necessari, i loro costi non sono così elevati perché le piattaforme non hanno bisogno di pagare per l'infrastruttura della rete.", - "page-dapps-collectibles-benefits-2-title": "Più giusto nei confronti degli autori", - "page-dapps-collectibles-benefits-3-description": "Gli articoli da collezione tokenizzati sono legati al tuo indirizzo Ethereum, non alla piattaforma. Quindi puoi vendere articoli, come ad esempio oggetti di un gioco, su qualsiasi marketplace Ethereum e non solo all'interno del gioco.", - "page-dapps-collectibles-benefits-3-title": "Gli articoli da collezione sono legati a te", - "page-dapps-collectibles-benefits-4-description": "Gli strumenti e i prodotti che ti permettono di tokenizzare le tue opere d'arte e venderle esistono già! E i tuoi token possono essere venduti su qualsiasi piattaforma di articoli da collezione Ethereum.", - "page-dapps-collectibles-benefits-4-title": "Infrastruttura già esistente", - "page-dapps-collectibles-benefits-description": "Si tratta di applicazioni incentrate sulla proprietà digitale, che aumentano il potenziale di guadagno per gli autori e inventano nuovi modi per investire nei tuoi autori preferiti e nel loro lavoro.", - "page-dapps-collectibles-benefits-title": "articoli da collezione decentralizzati e streaming", - "page-dapps-collectibles-button": "Arte e articoli da collezione", + "page-dapps-collectibles-benefits-2-description": "Pagare per riprodurre musica o acquistare opere d'arte è più corretto nei confronti degli artisti. Con Ethereum, la necessità degli intermediari è ridotta. E, se questi sono necessari, i loro costi non sono così tanto elevati, poiché le piattaforme non necessitano di pagare per l'infrastruttura della rete.", + "page-dapps-collectibles-benefits-2-title": "Più corretto per i creatori", + "page-dapps-collectibles-benefits-3-description": "Gli oggetti da collezione tokenizzati sono legati al tuo indirizzo di Ethereum, non alla piattaforma. Quindi, puoi vedere cose come gli oggetti di gioco su qualsiasi mercato di Ethereum, non soltanto nel gioco stesso.", + "page-dapps-collectibles-benefits-3-title": "Gli oggetti da collezione sono legati a te", + "page-dapps-collectibles-benefits-4-description": "Gli strumenti e prodotti per tokenizzare la tua arte e venderla, esistono già! E i tuoi token possono essere venduti su qualsiasi piattaforma di oggetti da collezione di Ethereum.", + "page-dapps-collectibles-benefits-4-title": "Infrastruttura pre-esistente", + "page-dapps-collectibles-benefits-description": "Si tratta di applicazioni incentrate sulla proprietà digitale, incrementando il potenziale di guadagno per i creatori e inventando nuovi metodi per investire sui tuoi creatori preferiti e sul loro lavoro.", + "page-dapps-collectibles-benefits-title": "oggetti da collezione decentralizzati e streaming", + "page-dapps-collectibles-button": "Arte e oggetti da collezione", "page-dapps-collectibles-description": "Si tratta di applicazioni incentrate sulla proprietà digitale, che aumentano il potenziale di guadagno per gli autori e inventano nuovi modi per investire nei tuoi autori preferiti e nel loro lavoro.", - "page-dapps-collectibles-title": "Opere d'arte e articoli da collezione decentralizzati", - "page-dapps-compound-logo-alt": "Logo Compound", - "page-dapps-cryptopunks-logo-alt": "Logo CryptoPunks", - "page-dapps-cryptovoxels-logo-alt": "Logo Cryptovoxels", - "page-dapps-dapp-description-1inch": "Ti aiuta a evitare uno slippage elevato dei prezzi aggregando quelli migliori.", - "page-dapps-dapp-description-aave": "Presta i tuoi token per ottenere interessi e preleva in qualsiasi momento.", - "page-dapps-dapp-description-async-art": "Crea, colleziona e scambia #ProgrammableArt. Dipinti digitali divisi in “Livelli” che è puoi usare per influenzare l'immagine generale. Ogni Master e Layer è un token ERC721.", - "page-dapps-dapp-description-audius": "Piattaforma di streaming decentralizzata. Ascolti = soldi per gli autori, non etichette.", + "page-dapps-collectibles-title": "Opere d'arte e oggetti da collezione decentralizzati", + "page-dapps-compound-logo-alt": "Logo di Compound", + "page-dapps-cryptopunks-logo-alt": "Logo di CryptoPunks", + "page-dapps-cryptovoxels-logo-alt": "Logo di Cryptovoxels", + "page-dapps-dapp-description-1inch": "Ti aiuta a evitare lo scivolamento elevato dei prezzi, aggregando quelli migliori.", + "page-dapps-dapp-description-aave": "Presta i tuoi token per maturare interessi, e preleva in qualsiasi momento.", + "page-dapps-dapp-description-async-art": "Crea, colleziona e scambia i dipinti digitali #ProgrammableArt, suddivisi in \"Livelli\", utilizzabili per influenzare l'immagine generale. Ogni Master e Layer è un token ERC-721.", + "page-dapps-dapp-description-audius": "Piattaforma di streaming decentralizzata. Ascolti = denaro per i creatori, non per le etichette.", "page-dapps-dapp-description-augur": "Scommetti sui risultati di sport, economia e altri eventi mondiali.", - "page-dapps-dapp-description-axie-infinity": "Scambia e fai combattere creature chiamate Axies. E guadagna mentre giochi. Disponibile su dispositivo mobile", - "page-dapps-dapp-description-balancer": "Balancer è un manager automatico del portafoglio e una piattaforma di trading.", + "page-dapps-dapp-description-axie-infinity": "Scambia e fai combattere creature, dette Axies. E guadagna giocando; disponibile su dispositivi mobili", + "page-dapps-dapp-description-balancer": "Balancer è un gestore automatico del portfolio, nonché piattaforma di trading.", "page-dapps-dapp-description-brave": "Guadagna token per navigare sul browser e supporta i tuoi autori preferiti.", - "page-dapps-dapp-description-cent": "Un social network in cui guadagni denaro pubblicando NFT.", + "page-dapps-dapp-description-cent": "Un social network in cui guadagni denaro, pubblicando NFT.", "page-dapps-dapp-description-compound": "Presta i tuoi token per ottenere interessi e preleva in qualsiasi momento.", - "page-dapps-dapp-description-cryptopunks": "Acquista, fai un'offerta e metti in vendita punk. Uno dei primi token da collezione su Ethereum.", - "page-dapps-dapp-description-cryptovoxels": "Crea gallerie d'arte, costruisci negozi e compra terreni. Un mondo virtuale Ethereum.", + "page-dapps-dapp-description-cryptopunks": "Acquista, rilancia e offri punk in vendita: uno dei primi token da collezione, su Ethereum.", + "page-dapps-dapp-description-cryptovoxels": "Crea gallerie d'arte e negozi e acquista terreni: un mondo virtuale di Ethereum.", "page-dapps-dapp-description-dark-forest": "Conquista pianeti in un universo infinito, generato proceduralmente e con specifiche crittografiche.", - "page-dapps-dapp-description-decentraland": "Colleziona, vendi e acquista terre virtuali in un mondo virtuale che puoi esplorare.", - "page-dapps-dapp-description-ens": "Nomi facili da usare per gli indirizzi Ethereum e siti decentralizzati.", - "page-dapps-dapp-description-foundation": "Investi in edizioni uniche di opere d'arte digitali e scambiale con altri acquirenti.", - "page-dapps-dapp-description-gitcoin": "Guadagna criptovalute lavorando con software open-source.", - "page-dapps-dapp-description-gitcoin-grants": "Crowdfunding per progetti della community Ethereum con contributi amplificati", - "page-dapps-dapp-description-gods-unchained": "Gioco di carte scambiabili strategico. Guadagna carte giocando e poi vendile nella vita reale.", - "page-dapps-dapp-description-golem": "Accedi a potenza di calcolo condivisa o noleggia le tue risorse.", - "page-dapps-dapp-description-radicle": "Collaborazione sicura basata su codice peer-to-peer senza intermediari.", - "page-dapps-dapp-description-loopring": "Piattaforma di trading peer-to-peer realizzata per essere veloce.", - "page-dapps-dapp-description-marble-cards": "Crea e scambia carte digitali uniche basate su URL.", - "page-dapps-dapp-description-matcha": "Cerca più cambi per aiutarti a trovare i prezzi migliori.", - "page-dapps-dapp-description-nifty-gateway": "Acquista opere on-chain dai migliori artisti, atleti, marchi e autori.", - "page-dapps-dapp-description-oasis": "Scambia, prendi in prestito e risparmia con Dai, uno stablecoin di Ethereum.", + "page-dapps-dapp-description-decentraland": "Colleziona e scambia terreni virtuali in un mondo virtuale, tutto da esplorare.", + "page-dapps-dapp-description-ens": "Nomi intuitivi per gli utenti, per indirizzi di Ethereum e siti decentralizzati.", + "page-dapps-dapp-description-foundation": "Investi in edizioni uniche di opere d'arte digitali, e scambia articoli con altri acquirenti.", + "page-dapps-dapp-description-gitcoin": "Guadagna criptovalute lavorando con software open source.", + "page-dapps-dapp-description-gitcoin-grants": "Crowdfunding per progetti della community di Ethereum, con contributi amplificati", + "page-dapps-dapp-description-gods-unchained": "Gioco strategico di carte scambiabili. Ottieni carte giocando, e rivendile nella vita reale.", + "page-dapps-dapp-description-golem": "Accedi a potenza di calcolo condivisa, o noleggia le tue risorse.", + "page-dapps-dapp-description-radicle": "Collaborazione tra pari al codice sicura e priva di intermediari.", + "page-dapps-dapp-description-loopring": "Piattaforma di trading tra pari, realizzata per essere veloce.", + "page-dapps-dapp-description-marble-cards": "Crea e scambia carte digitali uniche, basate sugli URL.", + "page-dapps-dapp-description-matcha": "Cerca più piattaforme di scambio per aiutarti a trovare i prezzi migliori.", + "page-dapps-dapp-description-nifty-gateway": "Acquista opere su catena dagli artisti, atleti, marchi e creatori più popolari.", + "page-dapps-dapp-description-oasis": "Scambia, prendi in prestito e risparmia con DAI, una Stablecoin di Ethereum.", "page-dapps-dapp-description-opensea": "Acquista, vendi, scopri e scambia beni in edizione limitata.", - "page-dapps-dapp-description-opera": "Invia criptovalute dal tuo browser a esercenti, altri utenti e app.", - "page-dapps-dapp-description-poap": "Raccogli NFT dimostrando di aver partecipato a diversi eventi virtuali o di persona. Usali per partecipare a lotterie, votare, collaborare o semplicemente per vantarti.", - "page-dapps-dapp-description-polymarket": "Scommetti sui risultati. Effettua negoziazioni sui mercati dell'informazione.", + "page-dapps-dapp-description-opera": "Invia criptovalute dal tuo browser ai commercianti, ad altri utenti e alle app.", + "page-dapps-dapp-description-poap": "Colleziona NFT che dimostrano che hai partecipato a diversi eventi virtuali o fisici. Utilizzali per partecipare a lotterie, votare, collaborare, o semplicemente per vantarti.", + "page-dapps-dapp-description-polymarket": "Scommetti sui risultati. Scambia sui mercati di informazioni.", "page-dapps-dapp-description-pooltogether": "Una lotteria dove non puoi perdere. Premi ogni settimana.", - "page-dapps-dapp-description-index-coop": "Un fondo indicizzato sulle criptovalute che espone il tuo portafoglio ai migliori token DeFi.", - "page-dapps-dapp-description-nexus-mutual": "Copertura senza l'agenzia d'assicurazione. Proteggiti dai bug e le hack dei contratti intelligenti.", - "page-dapps-dapp-description-etherisc": "Un modello di assicurazione decentralizzata utilizzabile da chiunque per creare la propria copertura assicurativa.", - "page-dapps-dapp-description-zapper": "Monitora il tuo portafoglio e usa una gamma di prodotti DeFi da un'interfaccia.", - "page-dapps-dapp-description-zerion": "Gestisci il tuo portafoglio e valuta semplicemente ogni singolo asset di DeFi sul mercato.", - "page-dapps-dapp-description-rotki": "Strumento di monitoraggio del portfolio open source, analisi, contabilità e rendicontazione fiscale, che rispetta la tua privacy.", - "page-dapps-dapp-description-krystal": "Una piattaforma unica per accedere a tutti i tuoi servizi DeFi preferiti.", - "page-dapps-dapp-description-rarible": "Crea, vendi e compra articoli da collezione tokenizzati.", + "page-dapps-dapp-description-index-coop": "Un fondo indicizzato di criptovalute, che espone al tuo portafoglio i migliori token della DeFi.", + "page-dapps-dapp-description-nexus-mutual": "Copertura senza l'agenzia assicurativa. Proteggiti dai bug e le hack dei contratti intelligenti.", + "page-dapps-dapp-description-etherisc": "Un modello assicurativo decentralizzato utilizzabile da chiunque, per creare la propria copertura assicurativa.", + "page-dapps-dapp-description-zapper": "Monitora il tuo portfolio e utilizza svariati prodotti della DeFi, da una singola interfaccia.", + "page-dapps-dapp-description-zerion": "Gestisci il tuo portfolio e, semplicemente, valuta ogni singola risorsa della DeFi sul mercato.", + "page-dapps-dapp-description-rotki": "Strumento di monitoraggio, analisi, contabilità e rendicontazione fiscale open source, che rispetta la tua privacy.", + "page-dapps-dapp-description-krystal": "Un'unica piattaforma, per accedere a tutti i tuoi servizi della DeFi preferiti.", + "page-dapps-dapp-description-rarible": "Crea, vendi e acquista oggetti da collezione tokenizzati.", "page-dapps-dapp-description-sablier": "Trasmetti denaro in tempo reale.", - "page-dapps-dapp-description-superrare": "Acquista opere d'arte digitali direttamente dagli artisti o nei mercati secondari.", - "page-dapps-dapp-description-token-sets": "Strategie di investimento in criptovalute che si riequilibrano automaticamente.", + "page-dapps-dapp-description-superrare": "Acquista opere d'arte digitali direttamente dagli artisti, o nei mercati secondari.", + "page-dapps-dapp-description-token-sets": "Strategie di investimento in criptovalute, che si riequilibrano automaticamente.", "page-dapps-dapp-description-tornado-cash": "Invia transazioni anonime su Ethereum.", - "page-dapps-dapp-description-uniswap": "Scambia token in modo facile o fornisci token per ricompense %.", + "page-dapps-dapp-description-uniswap": "Scambia semplicemente token o fornisci token per ricompense in percentuale.", + "page-dapps-dapp-description-dexguru": "Un terminale di trading privo di custodia, per i trader della DeFi", "page-dapps-docklink-dapps": "Introduzione alle dApp", "page-dapps-docklink-smart-contracts": "Contratti intelligenti", - "page-dapps-dark-forest-logo-alt": "Logo Dark Forest", - "page-dapps-decentraland-logo-alt": "Logo Decentraland", + "page-dapps-dark-forest-logo-alt": "Logo di Dark Forest", + "page-dapps-decentraland-logo-alt": "Logo di Decentraland", "page-dapps-index-coop-logo-alt": "Logo di Index Coop", "page-dapps-nexus-mutual-logo-alt": "Logo di Nexus Mutual", "page-dapps-etherisc-logo-alt": "Logo di Etherisc", @@ -97,120 +99,120 @@ "page-dapps-zerion-logo-alt": "Logo di Zerion", "page-dapps-rotki-logo-alt": "Logo di Rotki", "page-dapps-krystal-logo-alt": "Logo di Krystal", - "page-dapps-desc": "Trova un'applicazione Ethereum da provare.", - "page-dapps-doge-img-alt": "Figura di un cane che usa un computer", - "page-dapps-editors-choice-dark-forest": "Gioca contro altri utenti per conquistare pianeti e prova la tecnologia avanzatissima di scaling/privacy di Ethereum. Forse per coloro che già conoscono Ethereum.", - "page-dapps-editors-choice-description": "Alcune dapps che il team di ethereum.org adora in questo momento. Esplora più dapps qui sotto.", - "page-dapps-editors-choice-foundation": "Investi nella cultura. Compra, scambia e vendi opere d'arte digitali uniche e moda da alcuni incredibili artisti, musicisti e marchi.", + "page-dapps-desc": "Trova un'applicazione di Ethereum da provare.", + "page-dapps-doge-img-alt": "Illustrazione di un cane di razza doge, che utilizza un computer", + "page-dapps-editors-choice-dark-forest": "Gioca contro gli altri per conquistare pianeti e testa l'avanzatissima tecnologia di ridimensionamento e privacy di Ethereum. Forse, per coloro che conoscono già Ethereum.", + "page-dapps-editors-choice-description": "Alcune dapp del momento, adorate dal team di ethereum.org. Esplora altre dapp qui sotto.", + "page-dapps-editors-choice-foundation": "Investi in cultura. Acquista, scambia e vendi opere d'arte digitali uniche e moda da alcuni incredibili artisti, musicisti e marchi.", "page-dapps-editors-choice-header": "Scelte da noi", - "page-dapps-editors-choice-pooltogether": "Acquista un biglietto per la lotteria senza perdita. Ogni settimana, l'interesse generato dall'intera biglietteria viene inviato ad un fortunato vincitore. Riprendi i tuoi soldi quando vuoi.", - "page-dapps-editors-choice-uniswap": "Scambia i tuoi token con facilità. Uno dei preferiti della community, che ti permette di scambiare token con altri attraverso la rete.", - "page-dapps-ens-logo-alt": "Logo Ethereum Name Service", - "page-dapps-explore-dapps-description": "Molte dapp sono ancora in fase sperimentale, e si stanno testando le possibilità delle reti decentralizzate. Ma ci sono già stati successi nelle categorie tecnologia, finanza, giochi e articoli da collezione.", + "page-dapps-editors-choice-pooltogether": "Acquista un biglietto per la lotteria senza perdita. Ogni settimana, l'interesse generato dall'intero gruppo di biglietti, è inviato a un vincitore fortunato. Riprendi i tuoi soldi quando preferisci.", + "page-dapps-editors-choice-uniswap": "Scambia facilmente i tuoi token. Uno dei preferiti della community, che ti consente di scambiare token con gente, per tutta la rete.", + "page-dapps-ens-logo-alt": "Logo del Servizio del Nome di Ethereum", + "page-dapps-explore-dapps-description": "Molte dapp sono ancora sperimentali e stanno sperimentando con le possibilità delle reti decentralizzate. Ma ci sono già stati successi nelle categorie di tecnologia, finanza, videogiochi e oggetti da collezione.", "page-dapps-explore-dapps-title": "Esplora le dapp", - "page-dapps-features-1-description": "Una volta distribuito su Ethereum, il codice di una dapp non può essere rimosso. E chiunque può utilizzare le funzionalità della dapp, anche se il team che le ha sviluppate si è sciolto. Una volta su Ethereum, rimane lì.", + "page-dapps-features-1-description": "Una volta distribuito su Ethereum, il codice della dapp non può essere rimosso. E chiunque può utilizzare le funzionalità della dapp; anche se il team della dapp si scioglie, puoi continuare a utilizzarla. Una volta su Ethereum, vi rimane.", "page-dapps-features-1-title": "Nessun proprietario", - "page-dapps-features-2-description": "Nessuno può impedirti di usare una dapp o di inviare le transazioni. Ad esempio, se Twitter fosse su Ethereum, nessuno potrebbe bloccare il tuo profilo o impedirti di twittare.", - "page-dapps-features-2-title": "Nessuna censura", - "page-dapps-features-3-description": "Poiché Ethereum ha ETH, i pagamenti sono nativi di Ethereum. Gli sviluppatori non devono preoccuparsi dell'integrazione con intermediari terzi.", + "page-dapps-features-2-description": "Neessuno può impedirti di utilizzare una dapp o di inviare le transazioni. Ad esempio, se Twitter fosse su Ethereum, nessuno potrebbe bloccare il tuo profilo o impedirti di twittare.", + "page-dapps-features-2-title": "Libera dalla censura", + "page-dapps-features-3-description": "Poiché Ethereum ha gli ETH, i pagamenti sono nativi a Ethereum. Gli sviluppatori non devono preoccuparsi di integrarsi con fornitori di pagamento di terze parti.", "page-dapps-features-3-title": "Pagamenti integrati", - "page-dapps-features-4-description": "Il codice delle dapp è spesso aperto e compatibile per natura. I team sviluppano regolarmente utilizzando il lavoro di altri. Se vuoi permettere agli utenti di scambiare token nella tua dapp, puoi semplicemente integrare il codice di un'altra dapp.", + "page-dapps-features-4-description": "Il codice della dapp è spesso aperto e compatibile per natura. I team creano regolarmente utilizzando il lavoro altrui. Se desideri consentire agli utenti di scambiare token nella tua dapp, basta integrare il codice di un'altra dapp.", "page-dapps-features-4-title": "Plug and play", - "page-dapps-features-5-description": "Con gran parte delle dapp, non devi condividere la tua identità del mondo reale. Il tuo conto di Ethereum è il tuo accesso e necessiti soltanto di un portafoglio.", - "page-dapps-features-5-title": "Un solo login anonimo", - "page-dapps-features-6-description": "La crittografia assicura che gli utenti malevoli non possano forgiare transazioni e altre interazioni della dapp per conto tuo. Autorizzi le azioni delle dapp con il tuo conto di Ethereum, solitamente tramite il tuo portafoglio, così che le tue credenziali restino al sicuro.", - "page-dapps-features-6-title": "Il potere della crittografia", - "page-dapps-features-7-description": "Una volta che la dapp è su Ethereum, risulterà non disponibile solo se anche Ethereum non sarà disponibile. Le reti delle dimensioni di Ethereum sono notoriamente difficili da attaccare.", - "page-dapps-features-7-title": "Addio ai tempi di inattività", - "page-dapps-finance-benefits-1-description": "I servizi finanziari in esecuzione su Ethereum non hanno requisiti di iscrizione. Se disponi di fondi e di una connessione a Internet, puoi già partire.", + "page-dapps-features-5-description": "Con gran parte delle dapp, non devi condividere la tua identità reale. Il tuo conto di Ethereum è il tuo accesso, e necessiti soltanto di un portafoglio.", + "page-dapps-features-5-title": "Un accesso anonimo", + "page-dapps-features-6-description": "La crittografia assicura che gli utenti malevoli non possano forgiare le transazioni e le interazioni con altre dapp per conto tuo. Autorizzi le azioni della dapp con il tuo conto di Ethereum, solitamente tramite il tuo portafoglio, quindi, le tue credenziali restano al sicuro.", + "page-dapps-features-6-title": "Sostenute dalla crittografia", + "page-dapps-features-7-description": "Una volta che la dapp è su Ethereum, smetterà di essere disponibile soltanto se Ethereum non sarà più disponibile. Le reti delle dimensioni di Ethereum sono notoriamente difficili da attaccare.", + "page-dapps-features-7-title": "Nessuna inattività", + "page-dapps-finance-benefits-1-description": "I servizi finanziari operati su Ethereum non hanno requisiti di iscrizione. Se hai dei fondi e una connessione a Internet, sei pronto.", "page-dapps-finance-benefits-1-title": "Accesso aperto", - "page-dapps-finance-benefits-2-description": "C'è un intero mondo di token con cui è possibile interagire attraverso questi prodotti finanziari. La gente crea nuovi token su Ethereum in continuazione.", - "page-dapps-finance-benefits-2-title": "Una nuova economia basata su token", - "page-dapps-finance-benefits-3-description": "I team hanno creato gli stablecoin, una criptovaluta meno volatile che permette di sperimentare e utilizzare le criptovalute senza i rischi e le incertezze associate.", + "page-dapps-finance-benefits-2-description": "Esiste un intero mondo di token con cui puoi interagire, tramite questi prodotti finanziari. La gente crea nuovi token su Ethereum, in continuazione.", + "page-dapps-finance-benefits-2-title": "Una nuova economia basata sui token", + "page-dapps-finance-benefits-3-description": "I team hanno creato le Stablecoin: criptovalute meno volatili. Queste, ti consentono di sperimentare con e di utilizzare le criptovalute, senza rischi e incertezze.", "page-dapps-finance-benefits-3-title": "Stablecoin", - "page-dapps-finance-benefits-4-description": "I prodotti finanziari nello spazio Ethereum sono tutti modulari e compatibili tra loro. Sul mercato si affacciano nuove configurazioni di questi moduli in continuazione, che aumentano le possibilità offerte dalle criptovalute.", + "page-dapps-finance-benefits-4-description": "I prodotti finanziari nello spazio di Ethereum sono tutti modulari e compatibili tra loro. Le nuove configurazioni di tali moduli si affacciano continuamente sul mercato, aumentando le possibilità offerte dalle criptovalute.", "page-dapps-finance-benefits-4-title": "Servizi finanziari interconnessi", - "page-dapps-finance-benefits-description": "Perché Ethereum permette alle applicazioni finanziarie decentralizzate di prosperare?", + "page-dapps-finance-benefits-description": "Cos'è che consente alle applicazioni finanziarie decentralizzate, di prosperare su Ethereum?", "page-dapps-finance-benefits-title": "finanza decentralizzata", "page-dapps-finance-button": "Finanza", - "page-dapps-finance-description": "Si tratta di applicazioni incentrate sull'offerta di servizi finanziari tramite criptovalute. Offrono l'equivalente di prestiti, interessi e pagamenti privati, senza richiedere dati personali.", + "page-dapps-finance-description": "Si tratta di applicazioni incentrate sulla creazione di servizi finanziari, utilizzando le criptovalute. Offrono assunzione ed erogazione di prestiti, maturazione di interessi e pagamenti privati, senza richiedere alcun dato personale.", "page-dapps-finance-title": "Finanza decentralizzata", - "page-dapps-foundation-logo-alt": "Logo della Fondazione", - "page-dapps-gaming-benefits-1-description": "Gli oggetti sono negoziabili sui mercati degli articoli da collezione, che si tratti di terre virtuali o carte scambiabili. Gli oggetti dei tuoi giochi hanno valore reale.", - "page-dapps-gaming-benefits-1-title": "Gli oggetti dei giochi valgono il doppio come token", - "page-dapps-gaming-benefits-2-description": "Gli articoli sono tuoi e in alcuni casi anche i tuoi progressi, non delle aziende di gioco. Quindi non perderai nulla se l'azienda che ha creato il gioco viene attaccata, ha un malfunzionamento dei server o fallisce.", - "page-dapps-gaming-benefits-2-title": "I tuoi salvataggi sono salvi!", - "page-dapps-gaming-benefits-3-description": "Allo stesso modo i pagamenti di Ethereum possono essere verificati da chiunque, i giochi possono utilizzare questa qualità per garantire equità. In teoria, tutto è verificabile, dal numero di colpi critici alle dimensioni della cassa di guerra di un avversario.", + "page-dapps-foundation-logo-alt": "Logo della Ethereum Foundation", + "page-dapps-gaming-benefits-1-description": "Che si tratti di terreni virtuali o carte scambiabili, i tuoi oggetti sono scambiabili sui mercati di oggetti da collezione. I tuoi oggetti di gioco hanno un valore reale.", + "page-dapps-gaming-benefits-1-title": "Gli oggetti di gioco raddoppiano di valore come token", + "page-dapps-gaming-benefits-2-description": "Possiedi i tuoi oggetti e, in alcuni casi, i tuoi progressi, non le aziende videoludiche. Quindi, non perderai nulla se l'azienda che ha prodotto il gioco viene attaccata, soffre di un malfunzionamento dei server, o fallisce.", + "page-dapps-gaming-benefits-2-title": "I tuoi salvataggi sono al sicuro", + "page-dapps-gaming-benefits-3-description": "Così come i pagamenti di Ethereum sono disponibili per la verifica da parte di chiunque, i giochi possono sfruttare tale qualità per assicurare l'equità. In teoria, tutto è verificabile: dal numero di colpi critici alle dimensioni della cassa di guerra di un avversario.", "page-dapps-gaming-benefits-3-title": "Correttezza verificabile", - "page-dapps-gaming-benefits-description": "Perché Ethereum permette alle applicazioni di gaming decentralizzate di prosperare?", - "page-dapps-gaming-benefits-title": "giochi decentralizzati", + "page-dapps-gaming-benefits-description": "Cos'è che consente ai videogiochi decentralizzati, di prosperare su Ethereum?", + "page-dapps-gaming-benefits-title": "videogiochi decentralizzati", "page-dapps-gaming-button": "Gaming", - "page-dapps-gaming-description": "Si tratta di applicazioni che si concentrano sulla creazione di mondi virtuali e sul combattere contro altri giocatori usando articoli da collezione che hanno un valore nel mondo reale.", - "page-dapps-gaming-title": "Giochi decentralizzati", - "page-dapps-get-some-eth-description": "Le azioni dapp costano una commissione di transazione", - "page-dapps-get-started-subtitle": "Per provare una dapp, ti serve un portafoglio e qualche ETH. Un portafoglio ti permetterà di connetterti o di accedere. E avrai bisogno di ETH per pagare tutte le commissioni di transazione.", + "page-dapps-gaming-description": "Si tratta di applicazioni incentrate sulla creazione di mondi virtuali e combattimento con altri giocatori, utilizzando oggetti da collezione aventi un valore reale.", + "page-dapps-gaming-title": "Videogiochi decentralizzati", + "page-dapps-get-some-eth-description": "Le azioni delle dapp costano una commissione di transazione", + "page-dapps-get-started-subtitle": "Per provare una dapp, necessiterai di un portafoglio e di degli ETH. Un portafoglio ti consentirà di connetteri o di accedere. E necessiterai di degli ETH per pagare qualsiasi commissione di transazione.", "page-dapps-get-started-title": "Primi passi", - "page-dapps-gitcoin-grants-logo-alt": "Logo Gitcoin Grants", - "page-dapps-gitcoin-logo-alt": "Logo Gitcoin", - "page-dapps-gods-unchained-logo-alt": "Logo Gods Unchained", - "page-dapps-golem-logo-alt": "Logo Golem", + "page-dapps-gitcoin-grants-logo-alt": "Logo di Gitcoin Grants", + "page-dapps-gitcoin-logo-alt": "Logo di Gitcoin", + "page-dapps-gods-unchained-logo-alt": "Logo di Gods Unchained", + "page-dapps-golem-logo-alt": "Logo di Golem", "page-dapps-radicle-logo-alt": "Logo di Radicle", "page-dapps-hero-header": "Strumenti e servizi basati su Ethereum", - "page-dapps-hero-subtitle": "Le dapp sono un movimento crescente di applicazioni che usano Ethereum per interrompere modelli di business o inventarne di nuovi.", - "page-dapps-how-dapps-work-p1": "Il codice di backend (contratti intelligenti) delle dapp opera su una rete decentralizzata e non su un server centralizzato. Le dapp utilizzano la blockchain per l'archiviazione dei dati e i contratti intelligenti per la logica della loro app.", - "page-dapps-how-dapps-work-p2": "Un contratto intelligente è come una serie di regole che risiedono sulla catena, visibile a tutti e operata esattamente secondo tali regole. Immagina un distributore automatico: se gli fornisci abbastanza fondi e la selezione corretta, otterrai l'articolo che desideri. E come i distributori, i contratti intelligenti possono contenere fondi, proprio come il tuo conto di Ethereum. Questo consente al codice di mediare accordi e transazioni.", - "page-dapps-how-dapps-work-p3": "Una volta distribuite le dapp sulla rete di Ethereum, non puoi modificarle. Le dapp possono esser decentralizzate perché sono controllate dalla logica scritta nel contratto, non da un individuo o un'azienda.", + "page-dapps-hero-subtitle": "Le dapp sono un movimento crescente di applicazioni, che utilizzano Ethereum per interrompere i modelli aziendali o inventarne di nuovi.", + "page-dapps-how-dapps-work-p1": "Il codice del backend (contratti intelligenti) delle dapp, opera su una rete decentralizzata, non su un server centralizzato. Utilizzano la blockchain di Ethereum per l'archiviazione dei dati e i contratti intelligenti pr la logica dell'app.", + "page-dapps-how-dapps-work-p2": "Un contratto intelligente è una serie di regole che risiedono sulla catena, visibili a tutti e operati esattamente secondo tali regole. Immagina un distributore automatico: se gli fornisci abbastanza fondi e la selezione corretta, otterrai l'articolo desiderato. E come i distributori automatici, i contratti intelligenti possono detenere fondi molto simili al tuo conto di Ethereum. Ciò consente al codice di mediare accordi e transazioni.", + "page-dapps-how-dapps-work-p3": "Una volta distribuite le dapp sulla rete di Ethereum, non puoi modificarle. Le dapp possono essere decentralizzate poiché controllate dalla logica scritta nel contratto, non da un individuo o da un'azienda.", "page-dapps-how-dapps-work-title": "Come funzionano le dapp", "page-dapps-learn-callout-button": "Inizia a sviluppare", - "page-dapps-learn-callout-description": "Il nostro portale degli sviluppatori della community contiene documenti, strumenti e framework per aiutarti a costruire una dapp.", - "page-dapps-learn-callout-image-alt": "Figura di una mano che costruisce un simbolo ETH da mattoncini di Lego.", - "page-dapps-learn-callout-title": "Impara a costruire una dapp", - "page-dapps-loopring-logo-alt": "Logo Loopring", - "page-dapps-magic-behind-dapps-description": "Le dapp potrebbero sembrare normali app. In realtà, dietro le quinte, hanno alcune qualità speciali, perché ereditano tutti i superpoteri di Ethereum. Questo è ciò che rende le dapp diverse dalle app.", + "page-dapps-learn-callout-description": "Il nostro portale per sviluppatori della community include documentazioni, strumnti e quadri per aiutarti a creare la tua dapp.", + "page-dapps-learn-callout-image-alt": "Illustrazione di una mano, che crea un simbolo degli ETH, realizzato con mattoncini Lego.", + "page-dapps-learn-callout-title": "Impara a creare una dapp", + "page-dapps-loopring-logo-alt": "Logo di Loopring", + "page-dapps-magic-behind-dapps-description": "Le dapp potrebbero somigliare ad app regolari. In realtà, dietro le quinte, hanno alcune qualità speciali, poiché ereditano tutti i superpoteri di Ethereum. Ecco ciò che rende le dapp differenti dalle app.", "page-dapps-magic-behind-dapps-link": "Cosa rende Ethereum straordinario?", "page-dapps-magic-behind-dapps-title": "La magia delle dapp", "page-dapps-magic-title-1": "La magia", "page-dapps-magic-title-2": "delle", - "page-dapps-magician-img-alt": "Figura di maghi", - "page-dapps-marble-cards-logo-alt": "logo marble.cards", + "page-dapps-magician-img-alt": "Illustrazione di dei maghi", + "page-dapps-marble-cards-logo-alt": "Logo di marble.cards", "page-dapps-async-logo-alt": "Logo di Async", - "page-dapps-matcha-logo-alt": "Logo Matcha", - "page-dapps-mobile-options-header": "Cerca un'altra categoria", - "page-dapps-nifty-gateway-logo-alt": "Logo Nifty Gateway", - "page-dapps-oasis-logo-alt": "Logo Oasis", - "page-dapps-opensea-logo-alt": "Logo OpenSea", - "page-dapps-opera-logo-alt": "Logo Opera", - "page-dapps-polymarket-logo-alt": "Logo Polymarket", - "page-dapps-poap-logo-alt": "Logo del protocollo Proof of Attendance", - "page-dapps-pooltogether-logo-alt": "Logo PoolTogether", - "page-dapps-rarible-logo-alt": "Logo Rarible", + "page-dapps-matcha-logo-alt": "Logo di Matcha", + "page-dapps-mobile-options-header": "Sfoglia un'altra categoria", + "page-dapps-nifty-gateway-logo-alt": "Logo di Nifty Gateway", + "page-dapps-oasis-logo-alt": "Logo di Oasis", + "page-dapps-opensea-logo-alt": "Logo di OpenSea", + "page-dapps-opera-logo-alt": "Logo di Opera", + "page-dapps-polymarket-logo-alt": "Logo di Polymarket", + "page-dapps-poap-logo-alt": "Logo del Protocollo di Prova di Partecipazione", + "page-dapps-pooltogether-logo-alt": "Logo di PoolTogether", + "page-dapps-rarible-logo-alt": "Logo di Rarible", "page-dapps-ready-button": "Via!", "page-dapps-ready-description": "Scegli una dapp da provare", - "page-dapps-ready-title": "Pronti?", - "page-dapps-sablier-logo-alt": "Logo Sablier", - "page-dapps-set-up-a-wallet-button": "Trova portafoglio", - "page-dapps-set-up-a-wallet-description": "Un portafoglio è il tuo “login” per una dapp", + "page-dapps-ready-title": "Pronto?", + "page-dapps-sablier-logo-alt": "Logo di Sablier", + "page-dapps-set-up-a-wallet-button": "Trova un portafoglio", + "page-dapps-set-up-a-wallet-description": "Un portafoglio è il tuo \"accesso\" per una dapp", "page-dapps-set-up-a-wallet-title": "Configura un portafoglio", - "page-dapps-superrare-logo-alt": "Logo SuperRare", + "page-dapps-superrare-logo-alt": "Logo di SuperRare", "page-dapps-technology-button": "Tecnologia", - "page-dapps-technology-description": "Si tratta di applicazioni incentrate sul decentramento degli strumenti di sviluppo, l'integrazione dei sistemi criptoeconomici nella tecnologia esistente e la creazione di mercati per il lavoro di sviluppo open-source.", + "page-dapps-technology-description": "Si tratta di applicazioni incentrate sulla decentralizzazione degli strumenti per sviluppatori, incorporando sistemi criptoeconomici nella tecnologia esistente e creando mercati per il lavoro di sviluppo open source.", "page-dapps-technology-title": "Tecnologia decentralizzata", - "page-dapps-token-sets-logo-alt": "Logo Token Set", - "page-dapps-tornado-cash-logo-alt": "Logo Tornado Cash", - "page-dapps-uniswap-logo-alt": "Logo Uniswap", + "page-dapps-token-sets-logo-alt": "Logo di Token Set", + "page-dapps-tornado-cash-logo-alt": "Logo di Tornado Cash", + "page-dapps-uniswap-logo-alt": "Logo di Uniswap", "page-dapps-wallet-callout-button": "Trova portafoglio", - "page-dapps-wallet-callout-description": "I portafogli sono a loro volta delle dapp. Trovane uno basato sulle caratteristiche che più ti aggradano.", - "page-dapps-wallet-callout-image-alt": "Figura di un robot.", + "page-dapps-wallet-callout-description": "Anche i portafogli sono dapp. Trovane uno a seconda delle funzionalità adatte a te.", + "page-dapps-wallet-callout-image-alt": "Illustrazione di un robot.", "page-dapps-wallet-callout-title": "Visualizza i portafogli", "page-dapps-warning-header": "Fai sempre ricerche per verificare", - "page-dapps-warning-message": "Ethereum è una nuova tecnologia e la maggior parte delle applicazioni sono nuove. Prima di depositare grandi quantità di denaro, assicurati di conoscere i rischi.", + "page-dapps-warning-message": "Ethereum è una nuova tecnologia e, gran parte delle applicazioni, sono nuove. Prima di depositare qualsiasi grande quantità di denaro, assicurati di comprenderne i rischi.", "page-dapps-what-are-dapps": "Cosa sono le dapp?", - "page-dapps-more-on-defi-button": "Maggiori informazioni sulla finanza decentralizzata", - "page-dapps-more-on-nft-button": "Maggiori informazioni sugli oggetti collezionabili tokenizzati", - "page-dapps-more-on-nft-gaming-button": "Ulteriori informazioni sugli oggetti in-game tokenizzati", - "page-dapps-dapp-description-pwn": "Prestiti facili, garantiti da qualsiasi token o NFT su Ethereum.", - "page-dapps-pwn-image-alt": "Logo PWN", - "foundation": "Fondazione", + "page-dapps-more-on-defi-button": "Di più sulla finanza decentralizzata", + "page-dapps-more-on-nft-button": "Di più sugli oggetti collezionabili tokenizzati", + "page-dapps-more-on-nft-gaming-button": "Di più sugli oggetti di gioco tokenizzati", + "page-dapps-dapp-description-pwn": "Prestiti facili, garantiti da qualsiasi token o NFT, su Ethereum.", + "page-dapps-pwn-image-alt": "Logo di PWN", + "foundation": "Foundation", "transaction-fees": "Che cosa sono le commissioni sulle transazioni?", "page-wallets-get-some": "Ottieni ETH" } diff --git a/src/intl/it/page-developers-index.json b/src/intl/it/page-developers-index.json index 2f7e01a08b7..48fa9ab8b94 100644 --- a/src/intl/it/page-developers-index.json +++ b/src/intl/it/page-developers-index.json @@ -1,70 +1,70 @@ { - "page-developer-meta-title": "Risorse per sviluppatori Ethereum", - "page-developers-about": "Informazioni su queste risorse sviluppatore", - "page-developers-about-desc": "ethereum.org ti aiuta a sviluppare con Ethereum con documentazione sui concetti fondamentali e sullo stack di sviluppo. In più, ti offre tutorial per muovere i primi passi.", - "page-developers-about-desc-2": "Sull'onda della rete di sviluppatori Mozilla, abbiamo pensato che Ethereum avesse bisogno di un luogo in cui ospitare utili contenuti e risorse per sviluppatori. Come per Mozilla, qui è tutto open-source e disponibile per essere esteso e migliorato da voi.", + "page-developer-meta-title": "Risorse per Sviluppatori di Ethereum", + "page-developers-about": "Informazioni su queste risorse per sviluppatori", + "page-developers-about-desc": "ethereum.org è qui per aiutarti a sviluppare con Ethereum, con la documentazione sui concetti fondamentalii, nonché sullo stack di sviluppo. Inoltre, esistono dei tutorial per muovere i primi passi.", + "page-developers-about-desc-2": "Sull'onda della Rete di Sviluppatori di Mozilla, abbiamo pensato che Ethereum necessitasse di un luogo per ospiitare utili contenuti e risorse per sviluppatori. Come i nostri amici di Mozilla, anche qui tutto è open source e pronto all'estensione e al miglioramento.", "page-developers-account-desc": "Contratti o persone sulla rete", "page-developers-accounts-link": "Conti", "page-developers-advanced": "Avanzate", - "page-developers-api-desc": "Usare le librerie per interagire con i contratti intelligenti", + "page-developers-api-desc": "Utilizzare le librerie per interagire con i contratti intelligenti", "page-developers-api-link": "API del backend", - "page-developers-block-desc": "Batch di transazioni aggiunte alla blockchain", - "page-developers-block-explorers-desc": "Il portale per i dati Ethereum", + "page-developers-block-desc": "Gruppi di transazione, aggiunti alla blockchain", + "page-developers-block-explorers-desc": "Il tuo portale per i dati di Ethereum", "page-developers-block-explorers-link": "Esploratori di blocchi", "page-developers-blocks-link": "Blocchi", - "page-developers-browse-tutorials": "Scopri i tutorial", + "page-developers-browse-tutorials": "Sfoglia i tutorial", "page-developers-choose-stack": "Scegli il tuo stack", "page-developers-contribute": "Contribuisci", - "page-developers-dev-env-desc": "IDE adatti per lo sviluppo dapp", + "page-developers-dev-env-desc": "IDE adatti allo sviluppo di dapp", "page-developers-dev-env-link": "Ambienti di sviluppo", "page-developers-discord": "Unisciti a Discord", "page-developers-docs-introductions": "Introduzioni", - "page-developers-evm-desc": "Il computer che elabora transazioni", + "page-developers-evm-desc": "Il computer che elabora le transazioni", "page-developers-evm-link": "La Macchina Virtuale di Ethereum (EVM)", "page-developers-explore-documentation": "Esplora la documentazione", - "page-developers-feedback": "Puoi comunicarci il tuo feedback tramite una segnalazione GitHub o sul nostro server Discord.", - "page-developers-frameworks-desc": "Strumenti per rendere più rapido lo sviluppo", + "page-developers-feedback": "Se hai qualsiasi feedback, contattaci tramite un ticket di GitHub o sul nostro server di Discord.", + "page-developers-frameworks-desc": "Strumenti per velocizzare lo sviluppo", "page-developers-frameworks-link": "Quadri di sviluppo", "page-developers-fundamentals": "Fondamenti", "page-developers-gas-desc": "Ether necessari per le transazioni", "page-developers-gas-link": "Gas", "page-developers-get-started": "Come vorresti iniziare?", - "page-developers-improve-ethereum": "Aiutaci a rendere migliore ethereum.org", - "page-developers-improve-ethereum-desc": "Questi documenti sono il prodotto di un lavoro di gruppo, proprio come ethereum.org. Crea una segnalazione se trovi errori, vuoi proporre miglioramenti o nuove opportunità per aiutare gli sviluppatori Ethereum.", - "page-developers-into-eth-desc": "Introduzione alla blockchain e a Ethereum", - "page-developers-intro-ether-desc": "Un'introduzione alle criptovalute ed Ether", - "page-developers-intro-dapps-desc": "Introduzione alle applicazioni decentralizzate", + "page-developers-improve-ethereum": "Aiutaci a migliorare ethereum.org", + "page-developers-improve-ethereum-desc": "Così come ethereum.org, queste documentazioni sono uno sforzo della community. Crea una PR se trovi errori, vuoi proporre miglioramenti, o nuove opportunità per aiutare gli sviluppatori di Ethereum.", + "page-developers-into-eth-desc": "Un'introduzione alla blockchain e a Ethereum", + "page-developers-intro-ether-desc": "Un'introduzione alle criptovalute e all'Ether", + "page-developers-intro-dapps-desc": "Un'introduzione alle applicazioni decentralizzate", "page-developers-intro-dapps-link": "Introduzione alle dapp", "page-developers-intro-eth-link": "Introduzione a Ethereum", "page-developers-intro-ether-link": "Introduzione a Ether", "page-developers-intro-stack": "Introduzione allo stack", - "page-developers-intro-stack-desc": "Introduzione allo stack Ethereum", - "page-developers-js-libraries-desc": "Usare JavaScript per interagire con i contratti intelligenti", + "page-developers-intro-stack-desc": "Un'introduzione allo stack di Ethereum", + "page-developers-js-libraries-desc": "Utilizzare JavaScriipt per interagire con i contratti intelligenti", "page-developers-js-libraries-link": "Librerie di JavaScript", - "page-developers-language-desc": "Usare Ethereum con i linguaggi già familiari", + "page-developers-language-desc": "Utiliizzare Ethereum con linguaggi familiari", "page-developers-languages": "Linguaggi di programmazione", "page-developers-learn": "Imparare a sviluppare con Ethereum", - "page-developers-learn-desc": "Scopri i concetti fondamentali e lo stack Ethereum con i nostri documenti", + "page-developers-learn-desc": "Scopri i concetti fondamentali e lo stack di Ethereum, con le nostre documentazioni", "page-developers-learn-tutorials": "Impara con i tutorial", - "page-developers-learn-tutorials-cta": "Guarda i tutorial", - "page-developers-learn-tutorials-desc": "Impara a sviluppare passo-passo con Ethereum da sviluppatori già esperti.", - "page-developers-meta-desc": "Documentazione, tutorial e strumenti per sviluppatori che usano Ethereum.", + "page-developers-learn-tutorials-cta": "Visualizza i tutorial", + "page-developers-learn-tutorials-desc": "Impara a sviluppare con Ethereum passo dopo passo da sviluppatori già esperti.", + "page-developers-meta-desc": "Documentazioni, tutorial e strumenti per sviluppatori di Ethereum.", "page-developers-mev-desc": "Un'introduzione al valore estraibile massimo (MEV)", "page-developers-mev-link": "Valore estraibile massimo (MEV)", - "page-developers-mining-desc": "Come creare nuovi blocchi e raggiungere il consenso utilizzando il proof of work", + "page-developers-mining-desc": "Come sono creati i nuovi blocchi e com'era raggiunto il consenso, utilizzando il proof-of-work", "page-developers-mining-link": "Mining", "page-developers-mining-algorithms-desc": "Informazioni sugli algoritmi di mining di Ethereum", "page-developers-mining-algorithms-link": "Algoritmi di mining", - "page-developers-networks-desc": "Panoramica su rete principale e le reti di test", + "page-developers-networks-desc": "Una panoramica della Rete Principale e delle reti di prova", "page-developers-networks-link": "Reti", - "page-developers-node-clients-desc": "Come verificare blocchi e transazioni nella rete", + "page-developers-node-clients-desc": "Come sono verificati blocchi e transazioni, nella rete", "page-developers-node-clients-link": " Nodi e client", "page-developers-oracle-desc": "Inserire i dati esterni alla catena nei tuoi contratti intelligenti", "page-developers-oracles-link": "Oracoli", - "page-developers-play-code": "Prove con il codice", - "page-developers-read-docs": "Leggi i documenti", + "page-developers-play-code": "Gioca con il codice", + "page-developers-read-docs": "Leggi le documentazioni", "page-developers-scaling-desc": "Soluzioni per transazioni più rapide", - "page-developers-scaling-link": "Ampliamento", + "page-developers-scaling-link": "Ridimensionamento", "page-developers-smart-contract-security-desc": "Misure di sicurezza da considerare durante lo sviluppo dei contratti intelligenti", "page-developers-smart-contract-security-link": "Sicurezza dei contratti intelligenti", "page-developers-set-up": "Configurare l'ambiente locale", @@ -73,25 +73,25 @@ "page-developers-smart-contracts-link": "Contratti intelligenti", "page-developers-stack": "Lo stack", "page-developers-start": "Inizia a sperimentare", - "page-developers-start-desc": "Preferisci prima provare e porre domande in seguito?", - "page-developers-storage-desc": "Come gestire lo storage dapp", + "page-developers-start-desc": "Preferisci sperimentare prima, e poi porre le domande?", + "page-developers-storage-desc": "Come gestire l'archiviazione della dapp", "page-developers-storage-link": "Storage", - "page-developers-subtitle": "Un manuale su Ethereum, scritto da sviluppatori per sviluppatori.", + "page-developers-subtitle": "Un manuale per sviluppatori di Ethereum. Da e per sviluppatori.", "page-developers-title-1": "Ethereum", "page-developers-title-2": "sviluppatore", "page-developers-title-3": "risorse", - "page-developers-token-standards-desc": "Panoramica degli standard accettati per i token", - "page-developers-token-standards-link": "Standard per i token", + "page-developers-token-standards-desc": "Una panoramica degli standard di token accettati", + "page-developers-token-standards-link": "Standard dei token", "page-developers-transactions-desc": "Come cambia lo stato di Ethereum", "page-developers-transactions-link": "Transazioni", - "page-developers-web3-desc": "Perché il mondo web3 è diverso", - "page-developers-web3-link": "Web2 rispetto a Web3", + "page-developers-web3-desc": "In cosa differisce il mondo dello sviluppo in Web3", + "page-developers-web3-link": "Web2 vs Web3", "page-developers-networking-layer": "Livello di Rete", "page-developers-networking-layer-link": "Livello di Rete", "page-developers-networking-layer-desc": "Introduzione al livello di rete di Ethereum", "page-developers-data-structures-and-encoding": "Strutture di dati e codifica", "page-developers-data-structures-and-encoding-link": "Strutture di dati e codifica", - "page-developers-data-structures-and-encoding-desc": "Introduzione alle strutture di dati e allo schema di codifica usato nello stack di Ethereum", - "alt-eth-blocks": "Figura di blocchi organizzati come simbolo ETH", + "page-developers-data-structures-and-encoding-desc": "Introduzione alle strutture di dati e allo schema di codifica, utilizzati nello stack di Ethereum", + "alt-eth-blocks": "Illustrazione di blocchi organizzati come un simbolo di ETH", "page-assets-doge": "Doge che usa dapp" } diff --git a/src/intl/it/page-developers-learning-tools.json b/src/intl/it/page-developers-learning-tools.json index ae02234a82e..bfcc8a8985a 100644 --- a/src/intl/it/page-developers-learning-tools.json +++ b/src/intl/it/page-developers-learning-tools.json @@ -1,56 +1,56 @@ { - "page-learning-tools-bloomtech-description": "Il corso di Web3 di BloomTech ti insegnerà le abilità che i datori di lavoro cercano negli ingegneri.", + "page-learning-tools-bloomtech-description": "Il corso di Web3 di BloomTech ti insegnerà le competenze ricercate dai datori di lavoro, negli ingegneri.", "page-learning-tools-bloomtech-logo-alt": "Logo di BloomTech", - "page-learning-tools-bootcamps": "Bootcamp per sviluppatori", - "page-learning-tools-bootcamps-desc": "Corsi online a pagamento per mettersi in pari velocemente.", + "page-learning-tools-bootcamps": "Campi formativi per sviluppatori", + "page-learning-tools-bootcamps-desc": "Corsi online a pagamento per mettersi in pari, velocemente.", "page-learning-tools-browse-docs": "Sfoglia le documentazioni", - "page-learning-tools-capture-the-ether-description": "\"Capture the Ether\" è un gioco in cui violi i contratti intelligenti di Ethereum per imparare sulla sicurezza.", + "page-learning-tools-capture-the-ether-description": "\"Capture the Ether\" è un gioco in cui violi i contratti intelligenti di Ethereum, per imparare sulla sicurezza.", "page-learning-tools-capture-the-ether-logo-alt": "Logo di Capture the Ether", - "page-learning-tools-chainshot-description": "Bootcamp per sviluppatori di Ethereum da remoto con istruttore e corsi aggiuntivi.", + "page-learning-tools-chainshot-description": "Campo di formazione su Ethereum per sviluppatori, da remoto e con istruttore, e corsi aggiuntivi.", "page-learning-tools-chainshot-logo-alt": "Logo di ChainShot", - "page-learning-tools-coding": "Impara scrivendo codice", - "page-learning-tools-coding-subtitle": "Questi strumenti ti aiuteranno a sperimentare con Ethereum se preferisci un'esperienza d'apprendimento più interattiva.", - "page-learning-tools-consensys-academy-description": "Bootcamp online per sviluppatori di Ethereum.", + "page-learning-tools-coding": "Impara programmando", + "page-learning-tools-coding-subtitle": "Questi strumenti ti aiuteranno a sperimentare con Ethereum, se preferisci un'esperienza d'apprendimento più interattiva.", + "page-learning-tools-consensys-academy-description": "Campo di formazione online di Ethereum per sviluppatori.", "page-learning-tools-consensys-academy-logo-alt": "Logo di ConsenSys Academy", - "page-learning-tools-buildspace-description": "Impara sulle criptovalute creando progetti interessanti.", + "page-learning-tools-buildspace-description": "Impara sulle criptovalute, creando progetti interessanti.", "page-learning-tools-buildspace-logo-alt": "Logo di _buildspace", - "page-learning-tools-cryptozombies-description": "Impara Solidity creando il tuo gioco di Zombie.", + "page-learning-tools-cryptozombies-description": "Impara Solidity, creando il tuo gioco di zombie.", "page-learning-tools-cryptozombies-logo-alt": "Logo di CryptoZombies", "page-learning-tools-documentation": "Impara con la documentazione", - "page-learning-tools-documentation-desc": "Vuoi imparare di più? Vai alla nostra documentazione per trovare le spiegazioni di cui hai bisogno.", - "page-learning-tools-eth-dot-build-description": "Un sandbox educativo per web3, che include la programmazione trascina e rilascia e i blocchi di costruzione open source.", + "page-learning-tools-documentation-desc": "Vorresti imparare di più? Consulta la nostra documentazione per trovare le spiegazioni di cui hai bisogno.", + "page-learning-tools-eth-dot-build-description": "Un sandbox educativo per il Web3, che include la programmazione \"trascina e rilascia\" e i blocchi di costruzione open source.", "page-learning-tools-eth-dot-build-logo-alt": "Logo di Eth.build", "page-learning-tools-ethernauts-description": "Completa i livelli violando i contratti intelligenti.", "page-learning-tools-ethernauts-logo-alt": "Logo di Ethernauts", - "page-learning-tools-metaschool-description": "Diventa uno sviluppatore Web3 creando e lanciando dApps.", - "page-learning-tools-metaschool-logo-alt": "Logo _metaschool", + "page-learning-tools-metaschool-description": "Diventa uno Sviluppatore in Web3, creando e distribuendo dApp.", + "page-learning-tools-metaschool-logo-alt": "Logo di _metaschool", "page-learning-tools-game-tutorials": "Tutorial di gioco interattivi", - "page-learning-tools-game-tutorials-desc": "Impara giocando. Questi tutorial ti insegneranno le basi usando il gioco.", - "page-learning-tools-meta-desc": "Strumenti di programmazione basati sul web ed esperienze d'apprendimento interattive per aiutarti a sperimentare con lo sviluppo di Ethereum.", + "page-learning-tools-game-tutorials-desc": "Impara giocando. Questi tutorial ti insegneranno le basi, utilizzando il gioco.", + "page-learning-tools-meta-desc": "Strumenti di programmazione basati sul web ed esperienze d'apprendimento interattive, per aiutarti a sperimentare con lo sviluppo di Ethereum.", "page-learning-tools-meta-title": "Strumenti d'apprendimento per sviluppatori", - "page-learning-tools-questbook-description": "Tutorial per autodidatti per imparare il Web 3.0 sviluppando", + "page-learning-tools-questbook-description": "Tutorial per autodidatti, per imparare sul Web 3.0, sviluppando", "page-learning-tools-questbook-logo-alt": "Logo di Questbook", - "page-learning-tools-remix-description": "Sviluppa, distribuisci e amministra i contratti intelligenti per Ethereum. Segui i tutorial con il plugin di Learneth.", - "page-learning-tools-remix-description-2": "Remix, Replit e ChainIDE non sono semplici sandbox: gli sviluppatori possono scrivere, compilare e distribuire i propri contratti intelligenti.", - "page-learning-tools-replit-description": "Un ambiente di sviluppo personalizzabile per Ethereum con ricarica immediata, controllo degli errori e supporto della rete di prova di prima classe.", - "page-learning-tools-chainIDE-description": "Inizia il tuo viaggio verso il Web3 scrivendo contratti intelligenti per Ethereum con ChainIDE. Utilizza i modelli integrati per imparare e risparmiare tempo.", + "page-learning-tools-remix-description": "Sviluppa, distribuisci e amministra dei contratti intelligenti per Ethereum. Segui i tutorial con il plugin di Learneth.", + "page-learning-tools-remix-description-2": "Remix, Replit e ChainIDE non sono soltanto sandbox: utilizzandoli, gli sviluppatori possono scrivere, compilare e distribuire i propri contratti intelligenti.", + "page-learning-tools-replit-description": "Un ambiente di sviluppo personalizzabile per Ethereum con ricarica immediata, controllo degli errori e supporto per reti di prova di alta qualità.", + "page-learning-tools-chainIDE-description": "Inizia il tuo percorso verso il Web3, scrivendo contratti intelligenti per Ethereum con ChainIDE. Utilizza i modelli integrati per imparare e risparmiare tempo.", "page-learning-tools-chainIDE-logo-alt": "Logo di ChainIDE", "page-learning-tools-replit-logo-alt": "Logo di Replit", "page-learning-tools-remix-logo-alt": "Logo di Remix", - "page-learning-tools-sandbox": "Sandbox del codice", - "page-learning-tools-sandbox-desc": "Questi sandbox ti offriranno uno spazio per sperimentare con la scrittura dei contratti intelligenti e la comprensione di Ethereum.", - "page-learning-tools-speed-run-ethereum-description": "Speed Run Ethereum è una serie di sfide per testare la tua conoscenza di Solidity utilizzando Scaffold-ETH", + "page-learning-tools-sandbox": "Sandbox di codice", + "page-learning-tools-sandbox-desc": "Questi sandbox ti offriranno uno spazio per sperimentare con la scrittura dei contratti intelligenti, nonché per comprendere Ethereum.", + "page-learning-tools-speed-run-ethereum-description": "Speed Run Ethereum è una serie di sfide per testare le tue conoscenze in Solidity, utilizzando Scaffold-ETH", "page-learning-tools-speed-run-ethereum-logo-alt": "Logo di Speed Run Ethereum", - "page-learning-tools-studio-description": "Un IDE basato sul web in cui puoi seguire i tutorial per creare e testare i contratti intelligenti, nonché crearne un frontend.", - "page-learning-tools-vyperfun-description": "Impara a usare Vyper creando il tuo gioco Pokémon.", + "page-learning-tools-studio-description": "Un IDE basato sul web, in cui puoi seguire i tutorial per creare e testare i contratti intelligenti, nonché crearne un frontend.", + "page-learning-tools-vyperfun-description": "Impara a utilizzare Vyper, creando il tuo gioco di Pokémon.", "page-learning-tools-vyperfun-logo-alt": "Logo di Vyper.fun", - "page-learning-tools-nftschool-description": "Esplora cosa succede coi token non fungibili, o NFT, dal punto di vista tecnico.", - "page-learning-tools-nftschool-logo-alt": "Logo della scuola di NFT", - "page-learning-tools-pointer-description": "Impara le competenze degli sviluppatori web3 con tutorial interattivi e divertenti. Ottieni cripto-ricompense lungo il percorso", + "page-learning-tools-nftschool-description": "Esplora cosa succede con i token non fungibili, o NFT, dal punto di vista tecnico.", + "page-learning-tools-nftschool-logo-alt": "Logo di NFT School", + "page-learning-tools-pointer-description": "Apprendi le competenze di sviluppo in Web3 con tutorial interattivi e divertenti. Guadagna ricompense in criptovalute, lungo il percorso", "page-learning-tools-pointer-logo-alt": "Logo di Pointer", - "page-learning-tools-platzi-description": "Scopri come creare le dapp su Web3 e padroneggiare tutte le abilità necessarie per essere uno sviluppatore della blockchain.", + "page-learning-tools-platzi-description": "Impara come creare le dapp sul Web3 e padroneggia tutte le competenze necessarie per essere uno sviluppatore della blockchain.", "page-learning-tools-platzi-logo-alt": "Logo di Platzi", - "page-learning-tools-alchemy-university-description": "Sviluppa la tua carriera in web3 con corsi, progetti e programmazione.", + "page-learning-tools-alchemy-university-description": "Sviluppa la tua carriera in Web3 tramite corsi, progetti e programmazione.", "page-learning-tools-alchemy-university-logo-alt": "Logo di Alchemy University", - "alt-eth-blocks": "Figura di blocchi organizzati come simbolo ETH" + "alt-eth-blocks": "Illustrazione di blocchi organizzati come un simbolo di ETH" } diff --git a/src/intl/it/page-developers-local-environment.json b/src/intl/it/page-developers-local-environment.json index af310159ed5..138800fe7d1 100644 --- a/src/intl/it/page-developers-local-environment.json +++ b/src/intl/it/page-developers-local-environment.json @@ -1,35 +1,35 @@ { - "page-local-environment-brownie-desc": "Un framework di test e sviluppo basato su Python per i contratti intelligenti destinati alla Macchina Virtuale di Ethereum.", - "page-local-environment-brownie-logo-alt": "Logo Brownie", - "page-local-environment-epirus-desc": "Una piattaforma per lo sviluppo, la distribuzione e il monitoraggio delle applicazioni blockchain sulla macchina virtuale di Java.", - "page-local-environment-epirus-logo-alt": "Logo Epirus", - "page-local-environment-eth-app-desc": "Crea app basate su Ethereum con un comando. Viene fornito con un'ampia offerta di framework di interfaccia utente e modelli DeFi tra cui scegliere.", - "page-local-environment-eth-app-logo-alt": "Crea il logo dell'app Eth", - "page-local-environment-foundry-desc": "Un kit di strumenti incredibilmente veloce, portatile e modulare per lo sviluppo di applicazioni di Ethereum scritto in Rust.", + "page-local-environment-brownie-desc": "Un quadro di sviluppo e test basato su Python, per i contratti intelligenti indirizzati alla Macchina Virtuale di Ethereum.", + "page-local-environment-brownie-logo-alt": "Logo di Brownie", + "page-local-environment-epirus-desc": "Una piattaforma per lo sviluppo, la distribuzione e il monitoraggio delle applicazioni della blockchain, sulla Macchina Virtuale di Java.", + "page-local-environment-epirus-logo-alt": "Logo di Epirus", + "page-local-environment-eth-app-desc": "Crea app basate su Ethereum con un comando. Include un'ampia offerta di quadri UI e modelli di DeFi, tra cui scegliere.", + "page-local-environment-eth-app-logo-alt": "Logo di Create Eth App", + "page-local-environment-foundry-desc": "Un kit di strumenti incredibilmente veloce, portatile e modulare, per lo sviluppo di applicazioni di Ethereum scritte in Rust.", "page-local-environment-foundry-logo-alt": "Logo di Foundry", - "page-local-environment-framework-feature-1": "Funzionalità per avviare un'istanza blockchain locale.", + "page-local-environment-framework-feature-1": "Funzionalità per avviare un'istanza locale della blockchain.", "page-local-environment-framework-feature-2": "Utilità per compilare e testare i tuoi contratti intelligenti.", - "page-local-environment-framework-feature-3": "Componenti aggiuntivi per lo sviluppo su client per creare un'applicazione per gli utenti all'interno dello stesso progetto/repository.", - "page-local-environment-framework-feature-4": "Configurazione per connettersi alle reti di Ethereum e distribuire i contratti, che sia a un'istanza operata localmente o una delle reti pubbliche di Ethereum.", - "page-local-environment-framework-feature-5": "Distribuzione decentralizzata delle app. Integrazioni con opzioni di storage come IPFS.", - "page-local-environment-framework-features": "Questi framework sono dotati di molte funzionalità disponibili subito, come:", - "page-local-environment-frameworks-desc": " Ti consigliamo di scegliere un framework, soprattutto se hai appena iniziato. Costruire una dapp completa richiede diversi componenti della tecnologia. I framework includono molte delle funzionalità necessarie o forniscono semplici sistemi plug-in per scegliere gli strumenti desiderati.", - "page-local-environment-frameworks-title": "Framework e stack preimpostati", - "page-local-environment-hardhat-desc": "Hardhat è un ambiente di sviluppo Ethereum per professionisti.", - "page-local-environment-hardhat-logo-alt": "Logo Hardhat", + "page-local-environment-framework-feature-3": "Componenti aggiuntivi per lo sviluppo di client, per creare la tua applicazione rivolta agli utenti, in uno stesso progetto o una stessa repository.", + "page-local-environment-framework-feature-4": "Configurazione per connettersi alle reti di Ethereum e distribuire contratti, che sia per un'istanza eseguita localmente, o una delle reti pubbliche di Ethereum.", + "page-local-environment-framework-feature-5": "Distribuzione decentralizzata delle app: integrazioni con opzioni di archiviazione, come IPFS.", + "page-local-environment-framework-features": "Questi quadri sono dotati di molte funzionalità fuori dagli schemi, come:", + "page-local-environment-frameworks-desc": "Consigliamo di selezionare un quadro, in particolare se hai appena iniziato. Creare una dapp completa richiede numerosi componenti tecnologici. I quadri includono molte delle funzionalità necessarie, o forniscono facili sistemi di plugin, per selezionare gli strumenti desiderati.", + "page-local-environment-frameworks-title": "Quadri e stack precompilati", + "page-local-environment-hardhat-desc": "Hardhat è un ambiente di sviluppo di Ethereum per professionisti.", + "page-local-environment-hardhat-logo-alt": "Logo di Hardhat", "page-local-environment-openZeppelin-desc": "Risparmia ore di sviluppo compilando, aggiornando, distribuendo e interagendo con i contratti intelligenti, con la nostra CLI.", - "page-local-environment-openZeppelin-logo-alt": "Logo OpenZeppelin", - "page-local-environment-scaffold-eth-desc": "Ether + Hardhat + React: tutto ciò di cui hai bisogno per iniziare a creare applicazioni decentralizzate basate sui contratti intelligenti.", - "page-local-environment-scaffold-eth-logo-alt": "logo scaffold-eth", - "page-local-environment-setup-meta-desc": "Guida su come scegliere uno stack software per lo sviluppo Ethereum.", - "page-local-environment-setup-meta-title": "Configurazione di sviluppo locale Ethereum", - "page-local-environment-setup-subtitle": "Prima di iniziare a creare, è necessario scegliere uno stack.", - "page-local-environment-setup-subtitle-2": " Ecco gli strumenti e i framework che puoi utilizzare per creare un'applicazione Ethereum.", + "page-local-environment-openZeppelin-logo-alt": "Logo di OpenZeppelin", + "page-local-environment-scaffold-eth-desc": "Ether + Hardhat + React: tutto il necessario per iniziare a creare applicazioni decentralizzate, basate sui contratti intelligenti.", + "page-local-environment-scaffold-eth-logo-alt": "Logo di scaffold-eth", + "page-local-environment-setup-meta-desc": "Guida alla scelta dello stack del tuo software, per lo sviluppo su Ethereum.", + "page-local-environment-setup-meta-title": "Configurazione di sviluppo locale di Ethereum", + "page-local-environment-setup-subtitle": "Se sei pronto a iniziare a creare, è il momento di scegliere il tuo stack.", + "page-local-environment-setup-subtitle-2": "Ecco gli strumenti e quadri utilizzabili per aiutarti a creare la tua applicazione di Ethereum.", "page-local-environment-setup-title": "Configura il tuo ambiente di sviluppo locale", - "page-local-environment-solidity-template-desc": "Un modello di GitHub per una configurazione predefinita per i tuoi contratti intelligenti in Solidity. Include una rete locale Hardhat, Waffle per i test, Ether per l'implementazione del portafoglio, e molto altro.", - "page-local-environment-solidity-template-logo-alt": "Logo del modello Solidity", - "page-local-environment-truffle-desc": "Con la Truffle Suite, passare dall'idea alla dapp è comodissimo.", - "page-local-environment-truffle-logo-alt": "Logo Truffle", - "page-local-environment-waffle-desc": "La libreria di test più avanzata per i contratti intelligenti. Da usare da sola o con Scaffold-eth o Hardhat.", - "page-local-environment-waffle-logo-alt": "Logo Waffle" + "page-local-environment-solidity-template-desc": "Un modello di GitHub per una configurazione precompilata, per i tuoi contratti intelligenti in Solidity. Include una rete locale di Hardhat, Waffle per i test, Ethers per l'implementazione del portafoglio, e molto altro.", + "page-local-environment-solidity-template-logo-alt": "Logo del modello in Solidity", + "page-local-environment-truffle-desc": "Truffle Suits porta gli sviluppatori dall'idea alla dapp, nel modo più comodo possibile.", + "page-local-environment-truffle-logo-alt": "Logo di Truffle", + "page-local-environment-waffle-desc": "La libreria di test più avanzata per i contratti intelligenti. Da utilizzare da sola o con Scaffold-eth, o Hardhat.", + "page-local-environment-waffle-logo-alt": "Logo di Waffle" } diff --git a/src/intl/it/page-eth.json b/src/intl/it/page-eth.json index a19ae23c4f6..5732b2239a3 100644 --- a/src/intl/it/page-eth.json +++ b/src/intl/it/page-eth.json @@ -1,94 +1,94 @@ { "page-eth-buy-some": "Vuoi acquistare Ethereum?", - "page-eth-buy-some-desc": "Spesso si confonde Ethereum con ETH. Ethereum è la blockchain ed ETH è la risorsa principale di Ethereum. ETH è quello che probabilmente stai cercando di acquistare.", - "page-eth-cat-img-alt": "Grafica del glifo ETH con un caleidoscopio di gatti", - "page-eth-collectible-tokens": "Token di articoli da collezione", - "page-eth-collectible-tokens-desc": "Token che rappresentano un articolo da collezione di un gioco, un'opera d'arte digitale o altre risorse uniche. Comunemente noti come token non fungibili (NFTs).", + "page-eth-buy-some-desc": "È facile confondere Ethereum con ETH. Ethereum è la blockchain, ETH è la risorsa principale di Ethereum. Probabilmente, stai cercando di acquistare degli ETH.", + "page-eth-cat-img-alt": "Grafica del glifo di ETH con un caleidoscopio di gatti", + "page-eth-collectible-tokens": "Token da collezione", + "page-eth-collectible-tokens-desc": "Token rappresentanti un oggetto di gioco collezionabile, un'opera d'arte o altre risorse univoche. Comunemente noti come token non fungibili (NFT).", "page-eth-cryptography": "Protetto da crittografia", - "page-eth-cryptography-desc": "Il denaro di Internet può essere una novità, ma è protetto da una crittografia comprovata che rappresenta una protezione per il tuo portafoglio, i tuoi ETH e le tue transazioni. ", - "page-eth-currency-for-apps": "È la valuta delle app Ethereum.", - "page-eth-currency-for-future": "Valuta del nostro futuro digitale", - "page-eth-description": "ETH è una criptovaluta. È denaro digitale che è possibile utilizzare su Internet, analogamente ai Bitcoin. Se non hai esperienza nel campo delle criptovalute, ecco come ETH è diverso dal denaro tradizionale.", - "page-eth-earn-interest-link": "Ottenere interessi", - "page-eth-flexible-amounts": "Disponibile in quantitativi flessibili", - "page-eth-flexible-amounts-desc": "ETH è divisibile fino a 18 cifre decimali, in modo da non dover acquistare 1 ETH intero. Puoi acquistare frazioni alla volta, magari solo 0,000000000000000001 ETH se desideri.", - "page-eth-fuels": "ETH sta alla base di Ethereum e lo mantiene sicuro", - "page-eth-fuels-desc": "ETH è la linfa vitale di Ethereum. Quando invii ETH o usi un'applicazione di Ethereum, pagherai una commissione in ETH per usare la rete di Ethereum. Questa, è un incentivo per un produttore del blocco a elaborare e verificare ciò che stai provando a fare.", - "page-eth-fuels-desc-2": "I validatori sono come i custodi dei registri di Ethereum: controllano e provano che nessuno stia barando. Vengono selezionati a caso per proporre un blocco di transazioni. I validatori che svolgono questo lavoro vengono anche ricompensati con piccole quantità di ETH di nuova emissione.", - "page-eth-fuels-desc-3": "Il lavoro svolto dai validatori e il capitale da loro investito rendono Ethereum sicuro e libero dal controllo centralizzato.", - "page-eth-fuels-staking": "Mettendo i propri ETH in stake, si contribuisce a proteggere Ethereum e a guadagnare ricompense. In questo sistema, la minaccia di perdere ETH scoraggia gli aggressori.", - "page-eth-fuels-more-staking": "Maggiori informazioni sullo staking", - "page-eth-get-eth-btn": "Ottieni ETH", + "page-eth-cryptography-desc": "Il denaro di Internet potrà anche essere una novità, ma è protetto da una crittografia comprovata. Questa, protegge il tuo portafoglio, i tuoi ETH e le tue transazioni. ", + "page-eth-currency-for-apps": "È la valuta delle app di Ethereum.", + "page-eth-currency-for-future": "La valuta per il nostro futuro digitale", + "page-eth-description": "ETH è una criptovaluta. Si tratta di denaro digitale limitato, utilizzabile su Internet, analogamente ai Bitcoin. Se sei nuovo alle criptovalute, ecco in che modo gli ETH sono differenti dal denaro tradizionale.", + "page-eth-earn-interest-link": "Guadagna interessi", + "page-eth-flexible-amounts": "Disponibile in importi flessibili", + "page-eth-flexible-amounts-desc": "Gli ETH sono divisibili in fino a 18 cifre decimali, quindi, non devi acquistare 1 intero ETH. Puoi acquistarne frazioni alla volta, fino a 0,000000000000000001 ETH, se lo desideri.", + "page-eth-fuels": "Gli ETH alimentano e proteggono Ethereum", + "page-eth-fuels-desc": "Gli ETH sono la linfa vitale di Ethereum. Inviando ETH o utilizzando un'applicazione di Ethereum, pagherai una commissione in ETH per utilizzare la rete di Ethereum. Questa, è un incentivo per un produttore di blocchi, che elabora e verifica ciò che stai provando a fare.", + "page-eth-fuels-desc-2": "I validatori sono gli archivisti di Ethereum: verificano e provano che nessuno stia barando. Sono selezionati casualmente per proporre un blocco di transazioni. I validatori che compiono tale lavoro, sono inoltre ricompensati con piccole quantità di ETH di nuova emissione.", + "page-eth-fuels-desc-3": "Il lavoro svolto dai validatori, e il loro capitale investito, proteggono Ethereum, mantenendolo libero dal controllo centralizzato.", + "page-eth-fuels-staking": "Quando metti i tuoi ETH in staking, aiuti a proteggere Ethereum e guadagni ricompense. In questo sistema, la minaccia di perdere ETH, scoraggia gli utenti malevoli.", + "page-eth-fuels-more-staking": "Di più sullo staking", + "page-eth-get-eth-btn": "Ottieni degli ETH", "page-eth-gov-tokens": "Token di governance", - "page-eth-gov-tokens-desc": "Token che rappresentano il potere di voto in organizzazioni decentralizzate.", - "page-eth-has-value": "Perché ETH ha un valore?", - "page-eth-has-value-desc": "ETH è prezioso in modi diversi per persone diverse.", + "page-eth-gov-tokens-desc": "Token che rappresentano il potere di voto nelle organizzazioni decentralizzate.", + "page-eth-has-value": "Perché gli ETH hanno un valore?", + "page-eth-has-value-desc": "Gli ETH sono preziosi in modi diversi, per persone diverse.", "page-eth-has-value-desc-2": "Per gli utenti di Ethereum, ETH è prezioso perché consente di pagare le commissioni sulle transazioni.", - "page-eth-has-value-desc-3": "Altri lo considerano un deposito digitale di valore perché la creazione di nuovi ETH rallenta nel tempo.", - "page-eth-has-value-desc-4": "Più di recente, ETH è diventato prezioso per gli utenti di app finanziarie su Ethereum. Questo perché è possibile utilizzare ETH come garanzia per i prestiti in criptovalute o come sistema di pagamento.", - "page-eth-has-value-desc-5": "Naturalmente molti lo vedono anche come un investimento, analogamente a Bitcoin o altre criptovalute.", + "page-eth-has-value-desc-3": "Gli altri, lo considerano come un deposito di valore digitale, poiché la creazione di nuovi ETH rallenta nel tempo.", + "page-eth-has-value-desc-4": "Più di recente, gli ETH sono diventati preziosi per gli utenti delle app finanziarie su Ethereum. Questo perché puoi utilizzarli come garanzia per i prestiti di criptovalute, o come un sistema di pagamento.", + "page-eth-has-value-desc-5": "Naturalmente, inoltre, molti lo vedono come un investimento, al pari di Bitcoin o altre criptovalute.", "page-eth-how-to-buy": "Come acquistare Ether", - "page-eth-how-to-buy-caption": "Aggiornamento frequente", + "page-eth-how-to-buy-caption": "Aggiornato di frequente", "page-eth-is-money": "ETH è denaro digitale e globale.", "page-eth-last-updated": "Gennaio 2019", "page-eth-monetary-policy": "Politica monetaria di Ethereum", - "page-eth-more-on-ethereum-link": "Maggiori informazioni su Ethereum", + "page-eth-more-on-ethereum-link": "Di più su Ethereum", "page-eth-no-centralized": "Nessun controllo centralizzato ", - "page-eth-no-centralized-desc": "ETH è decentralizzato e globale. Non c'è azienda o banca che possa decidere di stampare più ETH o modificare le condizioni di utilizzo.", + "page-eth-no-centralized-desc": "ETH è decentralizzato e globale. Non c'è azienda o banca che possa decidere di stampare più ETH o modificarne i termini d'utilizzo.", "page-eth-non-fungible-tokens-link": "Token non fungibili", "page-eth-not-only-crypto": "ETH non è l'unica criptovaluta su Ethereum", - "page-eth-not-only-crypto-desc": "Chiunque può creare nuovi tipi di risorse e scambiarle su Ethereum. Sono conosciute come \"'token\". La gente ha tokenizzato le valute tradizionali, la proprietà, l'arte e persino se stessa!", - "page-eth-not-only-crypto-desc-2": "Ethereum ospita migliaia di token, alcuni più utili e preziosi di altri. Gli sviluppatori stanno costantemente creando nuovi token che sbloccano nuove possibilità e aprono nuovi mercati.", + "page-eth-not-only-crypto-desc": "Chiunque può creare nuovi tipi di risorse e scambiarle su Ethereum. Queste, sono note come 'token'. Le persone hanno tokenizzato le valute tradizionali, le proprie proprietà, la propria arte, e persino se stesse!", + "page-eth-not-only-crypto-desc-2": "Ethereum ospita migliaia di token, alcuni più utili e preziosi di altri. Gli sviluppatori creano costantemente nuovi token, che sbloccano nuove possibilità e aprono nuovi mercati.", "page-eth-open": "Aperto a chiunque", - "page-eth-open-desc": "Necessiti solo di una connessione a Internet e di un portafoglio per accettare gli ETH. Non devi accedere a un conto bancario per accettare i pagamenti. ", + "page-eth-open-desc": "Necessiti soltanto di una connessione a Internet e di un portafoglio per accettare gli ETH. Non devi accedere a un conto bancario per accettare i pagamenti. ", "page-eth-p2p-payments": "Pagamenti tra pari", - "page-eth-p2p-payments-desc": "È possibile inviare ETH senza servizi di intermediazione come le banche. È come consegnare denaro contante di persona, ma puoi farlo in modo sicuro con chiunque, ovunque, in qualsiasi momento.", + "page-eth-p2p-payments-desc": "Puoi inviare i tuoi ETH senza alcun servizio d'intermediazione come le banche. È come consegnare denaro contante di persona, ma in sicurezza, con chiunque, ovunque, e in qualsiasi momento.", "page-eth-period": ".", "page-eth-popular-tokens": "Tipi popolari di token", "page-eth-powers-ethereum": "ETH alimenta Ethereum", "page-eth-shit-coins": "Monete fasulle", - "page-eth-shit-coins-desc": "Perché fare nuovi token è facile, chiunque può farlo - anche le persone con cattive o sbagliate intenzioni. Fai sempre la tua ricerca prima di usarli!", + "page-eth-shit-coins-desc": "Poiché creare nuovi token è facile, chiunque può farlo: anche persone con intenzioni cattive o sbagliate. Svolgi sempre le dovute ricerche, prima di utilizzarli!", "page-eth-stablecoins": "Stablecoin", - "page-eth-stablecoins-desc": "Token che rispecchiano il valore della valuta tradizionale come i dollari. Questo risolve il problema della volatilità di molte criptovalute.", + "page-eth-stablecoins-desc": "Token che rispecchiano il valore della valuta tradizionale, come i dollari. Ciò risolve il problema della volatilità con molte criptovalute.", "page-eth-stablecoins-link": "Ottieni stablecoin", "page-eth-stream-link": "Trasmettere ETH", - "page-eth-tokens-link": "Token Ethereum", + "page-eth-tokens-link": "Token di Ethereum", "page-eth-trade-link-2": "Scambiare token", - "page-eth-underpins": "L'ETH è alla base del sistema finanziario Ethereum", - "page-eth-underpins-desc": "Non soddisfatta dei pagamenti, la community di Ethereum sta creando un intero sistema finanziario tra pari, accessibile a tutti.", - "page-eth-underpins-desc-2": "È possibile utilizzare ETH come garanzia per generare token di criptovaluta completamente diversi su Ethereum. Inoltre è possibile prendere in prestito, prestare e ottenere interessi su ETH e altri token basati su ETH.", + "page-eth-underpins": "Gli ETH sono alla base del sistema finanziario di Ethereum", + "page-eth-underpins-desc": "Insoddisfatta dai pagamenti, la community di Ethereum sta creando un intero sistema finanziario, che sia tra pari e accessibile a chiunque.", + "page-eth-underpins-desc-2": "Puoi utilizzare gli ETH come garanzia per generare token di criptovalute interamente differenti su Ethereum. Inoltre, puoi prendere in prestito, prestare e guadagnare interessi sugli ETH e su altri token sostenuti da ETH.", "page-eth-uses": "Gli impieghi degli ETH aumentano giorno dopo giorno", - "page-eth-uses-desc": "Poiché Ethereum è programmabile, gli sviluppatori possono modellarlo in innumerevoli modi.", - "page-eth-uses-desc-2": "Nel 2015, tutto quello che si poteva fare era inviare ETH da un conto di Ethereum a un altro. Ecco solo alcune delle cose che puoi fare oggi.", + "page-eth-uses-desc": "Poiché Ethereum è programmabile, gli sviluppatore possono modellare gli ETH in innumerevoli modi.", + "page-eth-uses-desc-2": "Nel 2015, tutto ciò che potevi fare era inviare ETH da un conto di Ethereum a un altro. Ecco soltanto alcune delle cose che puoi fare oggi.", "page-eth-uses-desc-3": "pagare qualcuno o ricevere fondi in tempo reale.", - "page-eth-uses-desc-4": "è possibile scambiare ETH con altri token tra cui Bitcoin.", + "page-eth-uses-desc-4": "scambiare ETH con altri token, Bitcoin inclusi.", "page-eth-uses-desc-5": "su ETH e altri token basati su Ethereum.", "page-eth-uses-desc-6": "accedere al mondo delle criptovalute con un valore costante e meno volatile.", "page-eth-value": "Perché ether è prezioso", - "page-eth-video-alt": "Video glifo ETH", + "page-eth-video-alt": "Video del glifo di ETH", "page-eth-whats-eth": "Cos'è ether (ETH)?", - "page-eth-whats-eth-hero-alt": "Figura di un gruppo di persone che si meravigliano del glifo di un ether (ETH)", - "page-eth-whats-eth-meta-desc": "Cosa devi sapere per capire ETH e il suo posto in Ethereum.", + "page-eth-whats-eth-hero-alt": "Illustrazione di un gruppo di persone, meravigliate da un glifo di ether (ETH)", + "page-eth-whats-eth-meta-desc": "Cosa devi sapere per comprendere gli ETH e il loro posto su Ethereum.", "page-eth-whats-eth-meta-title": "Cos'è ether (ETH)?", "page-eth-whats-ethereum": "Cos'è Ethereum?", - "page-eth-whats-ethereum-desc": "Se vuoi saperne di più su Ethereum e sulla tecnologia sottostante, dai un'occhiata alla nostra introduzione.", - "page-eth-whats-unique": "Cosa rende ETH unico?", - "page-eth-whats-unique-desc": "Sono presenti molte criptovalute e molti altri token su Ethereum, ma ci sono alcune cose che solo ETH può fare.", - "page-eth-where-to-buy": "Dove ottenere ETH", - "page-eth-where-to-buy-desc": "È possibile ottenere ETH da uno scambio o un portafoglio, ma ogni paese ha le sue politiche. Fai alcune ricerche per verificare quali servizi ti permettono di acquistare ETH.", - "page-eth-yours": "È davvero tuo", - "page-eth-yours-desc": "Con ETH, la tua banca sei tu. Puoi controllare i tuoi fondi con il portafoglio come prova di proprietà. Non sono necessarie terze parti.", - "page-eth-more-on-tokens": "Ulteriori informazioni sui token ed i loro utilizzi", + "page-eth-whats-ethereum-desc": "Se vorresti imparare di più su Ethereum, la tecnologia dietro gli ETH, consulta la nostra introduzione.", + "page-eth-whats-unique": "Cosa rende gli ETH unici?", + "page-eth-whats-unique-desc": "Esistono molte criptovalute e molti altri token su Ethereum, ma ci sono delle cose che soltanto ETH può fare.", + "page-eth-where-to-buy": "Dove ottenere gli ETH", + "page-eth-where-to-buy-desc": "Puoi ottenere ETH da una piattaforma di scambio o da un portafoglio, ma paesi diversi hanno politiche diverse. Verifica i servizi che ti consentono di acquistare ETH.", + "page-eth-yours": "Sono davvero tuoi", + "page-eth-yours-desc": "Gli ETH ti consentono di essere la tua banca. Puoi controllare i tuoi fondi con il tuo portafoglio, come prova di proprietà. Non sono necessarie terze parti.", + "page-eth-more-on-tokens": "Di più sui token e sui loro utilizzi", "page-eth-button-buy-eth": "Ottieni ETH", "page-eth-tokens-stablecoins": "Stablecoin", "page-eth-tokens-defi": "Finanza Decentralizzata (DeFi)", "page-eth-tokens-nft": "Token non fungibili (NFT)", "page-eth-tokens-dao": "Organizzazioni autonome decentralizzate (DAO)", - "page-eth-tokens-stablecoins-description": "Maggiori informazioni sugli Ethereum token meno volatili.", - "page-eth-tokens-defi-description": "Il sistema finanziario degli Ethereum token.", - "page-eth-tokens-nft-description": "Token che rappresentano il possesso di elementi su Ethereum.", - "page-eth-tokens-dao-description": "Community virtuali spesso governate da possessori di token.", - "page-eth-whats-defi": "Maggiori informazioni sulla DeFi", - "page-eth-whats-defi-description": "DeFi è il sistema finanziario decentralizzato basato su Ethereum. Questa panoramica spiega cosa puoi fare.", + "page-eth-tokens-stablecoins-description": "Di più sui token di Ethereum meno volatili.", + "page-eth-tokens-defi-description": "Il sistema finanziario dei token di Ethereum.", + "page-eth-tokens-nft-description": "Token che rappresentano il possesso di articoli su Ethereum.", + "page-eth-tokens-dao-description": "Community virtuali, spesso governate dai possessori di token.", + "page-eth-whats-defi": "Di più sulla DeFi", + "page-eth-whats-defi-description": "La DeFi è il sistema finanziario decentralizzato, basato su Ethereum. Questa panoramica spiega cosa puoi fare.", "page-what-is-ethereum-what-is-ether": "Cos'è un ether?" } diff --git a/src/intl/it/page-get-eth.json b/src/intl/it/page-get-eth.json index 41656d28c0c..72f3567c033 100644 --- a/src/intl/it/page-get-eth.json +++ b/src/intl/it/page-get-eth.json @@ -2,65 +2,65 @@ "page-get-eth-article-keeping-crypto-safe": "I segreti per tenere al sicuro le tue criptovalute", "page-get-eth-article-protecting-yourself": "Proteggere te e i tuoi fondi", "page-get-eth-article-store-digital-assets": "Come conservare attivi digitali su Ethereum", - "page-get-eth-cex": "Borse centralizzate", - "page-get-eth-cex-desc": "Gli scambi sono aziende che consentono di acquistare criptovalute usando valute tradizionali. Hanno la custodia su tutti gli ETH che acquisti fino a quando li invii a un portafoglio che controlli.", - "page-get-eth-checkout-dapps-btn": "Scopri le dapp", + "page-get-eth-cex": "Piattaforme di scambio centralizzate", + "page-get-eth-cex-desc": "Le piattaforme di scambio sono aziende che ti consentono di acquistare criptovalute, utilizzando valute tradizionali. Hanno la custodia su qualsiasi ETH che acquisti, finché non li invii a un portafoglio che controlli.", + "page-get-eth-checkout-dapps-btn": "Dai un'occhiata alle dapp", "page-get-eth-community-safety": "Post della community sulla sicurezza", - "page-get-eth-description": "Ethereum ed ETH non sono controllati da nessun governo o azienda, sono decentralizzati. Significa che gli ETH possono essere utilizzati da tutti.", - "page-get-eth-dex": "Borse decentralizzate (DEX)", - "page-get-eth-dex-desc": "Se vuoi più controllo, compra ETH peer-to-peer. Con una DEX puoi acquistare e vendere senza dare a un'azienda centralizzata il controllo dei tuoi fondi.", + "page-get-eth-description": "Ethereum ed ETH non sono controllati da alcun governo o azienda: sono decentralizzati. Ciò significa che gli ETH sono utilizzabili da tutti.", + "page-get-eth-dex": "Piattaforme di scambio decentralizzate (DEX)", + "page-get-eth-dex-desc": "Se desideri un maggiore controllo, acquista ETH tra pari. Con una DEX puoi scambiare senza concedere il controllo dei tuoi fondi a un'azienda centralizzata.", "page-get-eth-dexs": "Borse decentralizzate (DEX)", - "page-get-eth-dexs-desc": "Le borse decentralizzate sono piazze aperte in cui scambiare ETH e altri token. Collegano direttamente acquirenti e venditori.", - "page-get-eth-dexs-desc-2": "Invece di sfruttare una terza parte attendibile per salvaguardare i fondi nella transazione, utilizzano il codice. L'ETH del venditore sarà trasferito solo quando il pagamento è garantito. Questo tipo di codice è noto come contratto intelligente.", - "page-get-eth-dexs-desc-3": "Tutto questo significa che ci sono meno restrizioni geografiche rispetto alle alternative centralizzate. Se qualcuno vende ciò che cerchi e accetta un metodo di pagamento fornisci, puoi procedere. Con le DEX puoi acquistare ETH con altri token, Paypal o anche contanti di persona.", + "page-get-eth-dexs-desc": "Le piattaforme di scambio decentralizzate sono mercati aperti per gli ETH e per altri token. Connettono direttamente gli acquirenti ai venditori.", + "page-get-eth-dexs-desc-2": "Invece di utilizzare una terza parte attendibile per salvaguardare i fondi nella transazione, utilizzano il codice. Gli ETH del venditore saranno trasferiti soltanto quando il pagamento è garantito. Questo tipo di codice è noto come contratto intelligente.", + "page-get-eth-dexs-desc-3": "Ciò significa che siano presenti meno limitazioni geografiche, rispetto che con le alternative centralizzate. Se qualcuno sta vendendo ciò che desideri e accetta un metodo di pagamento che puoi fornire, puoi procedere. Le DEX possono consentirti di acquistare ETH con altri token, via PayPal, o persino con consegne di denaro di persona.", "page-get-eth-do-not-copy": "Esempio: Non copiare", - "page-get-eth-exchanges-disclaimer": "Abbiamo raccolto questa informazione manualmente. Se trovi qualcosa di sbagliato, faccelo sapere:", - "page-get-eth-exchanges-empty-state-text": "Inserisci il tuo paese di residenza per vedere una lista di portafogli e scambi che puoi usare per acquistare ETH", - "page-get-eth-exchanges-except": "Eccetto", + "page-get-eth-exchanges-disclaimer": "Abbiamo raccolto queste informazioni manualmente. Se trovi qualcosa di sbagliato, faccelo sapere", + "page-get-eth-exchanges-empty-state-text": "Inserisci il tuo paese di residenza, per visualizzare un elenco di portafogli e piattaforma di scambio che puoi utilizzare, per acquistare ETH", + "page-get-eth-exchanges-except": "Tranne", "page-get-eth-exchanges-header": "In che paese vivi?", - "page-get-eth-exchanges-header-exchanges": "Scambi", + "page-get-eth-exchanges-header-exchanges": "Piattaforme di scambio", "page-get-eth-exchanges-header-wallets": "Portafogli", - "page-get-eth-exchanges-intro": "Borse e portafogli hanno restrizioni sul luogo di vendita delle criptovalute.", - "page-get-eth-exchanges-no-exchanges": "Siamo spiacenti, non conosciamo borse che ti permettano di acquistare ETH da questo paese. Se tu le conosci, faccelo sapere:", - "page-get-eth-exchanges-no-exchanges-or-wallets": "Siamo spiacenti, non conosciamo borse o portafogli che ti permettano di acquistare ETH da questo paese. Se tu li conosci, faccelo sapere:", - "page-get-eth-exchanges-no-wallets": "Siamo spiacenti, non conosciamo portafogli che ti permettano di acquistare ETH da questo paese. Se tu li conosci, faccelo sapere:", + "page-get-eth-exchanges-intro": "Piattaforme di scambio e portafogli, presentano restrizioni sul luogo di vendita delle criptovalute.", + "page-get-eth-exchanges-no-exchanges": "Spiacenti, non conosciamo alcuna piattaforma di scambio che consenta di acquistare ETH da questo paese. Se ne conosci qualcuna, faccelo sapere a", + "page-get-eth-exchanges-no-exchanges-or-wallets": "Spiacenti, non conosciamo alcuna piattaforma di scambio o portafoglio che consenta di acquistare ETH da questo paese. Se ne conosci qualcuna, faccelo sapere a", + "page-get-eth-exchanges-no-wallets": "Spiacenti, non conosciamo alcun portafoglio che consenta di acquistare ETH da questo paese. Se ne conosci qualcuna, faccelo sapere a", "page-get-eth-exchanges-search": "Digita dove vivi...", - "page-get-eth-exchanges-success-exchange": "La registrazione a una borsa può richiedere diversi giorni a causa dei controlli legali da eseguire.", + "page-get-eth-exchanges-success-exchange": "La registrazione con una piattaforma di scambio può richiedere diversi giorni, a causa dei controlli legali che effettua.", "page-get-eth-exchanges-success-wallet-link": "portafogli", "page-get-eth-exchanges-success-wallet-paragraph": "Nel paese in cui vivi, puoi acquistare ETH direttamente da questi portafogli. Scopri di più su", "page-get-eth-exchanges-usa": "Stati Uniti d'America (USA)", "page-get-eth-get-wallet-btn": "Ottieni un portafoglio", "page-get-eth-hero-image-alt": "Ottieni l'immagine dell'eroe di ETH", - "page-get-eth-keep-it-safe": "Proteggere i tuoi ETH", - "page-get-eth-meta-description": "Come acquistare ETH a seconda di dove vivi e consigli su come prendersene cura.", + "page-get-eth-keep-it-safe": "Proteggi i tuoi ETH", + "page-get-eth-meta-description": "Come acquistare ETH a seconda di dove vivi, e consigli su come proteggerli.", "page-get-eth-meta-title": "Come acquistare ETH", - "page-get-eth-need-wallet": "Ti servirà un portafoglio per usare una DEX.", + "page-get-eth-need-wallet": "Necessiterai di un portafoglio, per utilizzare una DEX.", "page-get-eth-new-to-eth": "Alle prime armi con ETH? Ecco una panoramica per muovere i primi passi.", "page-get-eth-other-cryptos": "Acquista con altre criptovalute", - "page-get-eth-protect-eth-desc": "Se prevedi di acquistare molti ETH, potresti volerli conservare in un portafoglio che controlli, anziché in una borsa. Questo perché una borsa potrebbe esser bersaglio di hacker. Se un hacker ottiene l'accesso, potresti perdere i tuoi fondi. Al contrario, solo tu puoi controllare il tuo portafoglio.", + "page-get-eth-protect-eth-desc": "Se prevedi di acquistare molti ETH, potresti volerli conseervare in un portafoglio che controlli, anziché in una piattaforma di scambio. Questo perché una piattaforma di scambio potrebbe essere soggetta ad attacchi di hacker. Se questi ottengono l'accesso, potresti perdere i tuoi fondi. Al contrario, soltanto tu hai il controllo del tuo portafoglio.", "page-get-eth-protect-eth-in-wallet": "Proteggi i tuoi ETH in un portafoglio", "page-get-eth-search-by-country": "Cerca per paese", - "page-get-eth-security": "Ma questo significa anche che devi prendere sul serio la sicurezza dei tuoi fondi. Con ETH, non ti affidi a una banca perché controlli il tuo denaro, ti affidi a te stesso.", + "page-get-eth-security": "Ma ciò significa anche che devi prendere sul serio la sicurezza dei tuoi fondi. Con gli ETH, non ti affidi a una banca perché controlli il tuo denaro, ti affidi a te stesso.", "page-get-eth-smart-contract-link": "Di più sui contratti intelligenti", "page-get-eth-swapping": "Scambia i tuoi token per gli ETH di altre persone. E viceversa.", "page-get-eth-try-dex": "Prova una DEX", "page-get-eth-use-your-eth": "Usa i tuoi ETH", - "page-get-eth-use-your-eth-dapps": "Ora che possiedi alcuni ETH, dai un'occhiata ad alcune applicazioni di Ethereum (dapp). Esistono dapp per la finanza, social media, videogiochi e molte di altre categorie.", + "page-get-eth-use-your-eth-dapps": "Ora che possiedi degli ETH, dai un'occhiata ad alcune applicazioni (dapp) di Ethereum. Ne esistono per la finanza, per i social, i videogiochi e molte altre categorie.", "page-get-eth-wallet-instructions": "Segui le istruzioni del portafoglio", - "page-get-eth-wallet-instructions-lost": "Se perdi l'accesso al tuo portafoglio, perderai l'accesso ai tuoi fondi. Il tuo portafoglio dovrebbe darti le istruzioni per evitarlo. Assicurati di seguirle attentamente; in gran parte dei casi, nessuno può aiutarti se perdi l'accesso al tuo portafoglio.", + "page-get-eth-wallet-instructions-lost": "Se perdi l'accesso al tuo portafoglio, perderai l'accesso ai tuoi fondi. Il tuo portafoglio dovrebbe fornirti le istruzioni per evitarlo. Assicurati di seguirle attentamente; in gran parte dei casi, nessuno può aiutarti se perdi l'accesso al tuo portafoglio.", "page-get-eth-wallets": "Portafogli", "page-get-eth-wallets-link": "Di più sui portafogli", "page-get-eth-wallets-purchasing": "Alcuni portafogli, ti consentono di acquistare criptovalute con una carta di debito/credito, bonifico bancario o persino Apple Pay. Si applicano le limitazioni geografiche.", - "page-get-eth-warning": "Queste DEX non sono per principianti, poiché avrai bisogno di ETH per usarle.", + "page-get-eth-warning": "Queste DEX non sono per principianti, poiché necessiterai di degli ETH, per utilizzarle.", "page-get-eth-what-are-DEX's": "Cosa sono le DEX?", - "page-get-eth-whats-eth-link": "Cos'è l'ETH?", - "page-get-eth-where-to-buy-desc": "Puoi acquistare ETH direttamente dalle borse o dai portafogli.", - "page-get-eth-where-to-buy-desc-2": "Controlla quali servizi puoi usare in base al luogo in cui vivi.", + "page-get-eth-whats-eth-link": "Cosa sono gli ETH?", + "page-get-eth-where-to-buy-desc": "Puoi acquistare ETH direttamente dalle piattaforme di scambio o dai portafogli.", + "page-get-eth-where-to-buy-desc-2": "Controlla quali servizi puoi utilizzare, a seconda di dove vivi.", "page-get-eth-where-to-buy-title": "Dove acquistare ETH", "page-get-eth-your-address": "Il tuo indirizzo ETH", - "page-get-eth-your-address-desc": "Quando scarichi un portafoglio, ti verrà creato un indirizzo ETH pubblico, che si presenta così:", - "page-get-eth-your-address-desc-3": "Puoi considerarlo come un indirizzo email, su cui invece delle email riceverai ETH. Se vuoi trasferire ETH da una borsa al tuo portafoglio, usa questo indirizzo come destinazione. Controlla sempre due volte prima di confermare l'invio!", - "page-get-eth-your-address-wallet-link": "Scopri i portafogli", + "page-get-eth-your-address-desc": "Quando scarichi un portafoglio, questo, creerà un indirizzo ETH pubblico per te. Ecco come si presenta:", + "page-get-eth-your-address-desc-3": "Consideralo come il tuo indirizzo email ma, invece delle email, può ricevere ETH. Se desideri trasferire ETH da una piattaforma di scambio al tuo portafoglio, utilizza il tuo indirizzo come la destinazione. Assicurati di ricontrollare sempre, prima di procedere all'invio!", + "page-get-eth-your-address-wallet-link": "Dai un'occhiata ai portafogli", "listing-policy-raise-issue-link": "Apri segnalazione", "page-find-wallet-last-updated": "Ultimo aggiornamento" } diff --git a/src/intl/it/page-index.json b/src/intl/it/page-index.json index 92f25f82a14..7c69d79c202 100644 --- a/src/intl/it/page-index.json +++ b/src/intl/it/page-index.json @@ -8,71 +8,70 @@ "page-index-get-started": "Primi passi", "page-index-get-started-description": "ethereum.org è il tuo portale sul mondo di Ethereum. La tecnologia è nuova e in continua evoluzione, avere una guida è d'aiuto. Ecco cosa ti consigliamo per entrare a farne parte.", "page-index-get-started-image-alt": "Illustrazione di una persona che lavora al computer.", - "page-index-get-started-wallet-title": "Scegli un wallet", - "page-index-get-started-wallet-description": "Con un wallet puoi connetterti a Ethereum e gestire i tuoi fondi.", - "page-index-get-started-wallet-image-alt": "Illustrazione di un robot con una cassaforte come corpo, che rappresenta un portafoglio Ethereum.", + "page-index-get-started-wallet-title": "Scegli un portafoglio", + "page-index-get-started-wallet-description": "Un portafoglio consente di connetterti a Ethereum e di gestire i tuoi fondi.", + "page-index-get-started-wallet-image-alt": "Illustrazione di un robot con una cassaforte come corpo, che rappresenta un portafoglio di Ethereum.", "page-index-get-started-eth-title": "Ottieni ETH", "page-index-get-started-eth-description": "ETH è la valuta di Ethereum: puoi usarla nelle applicazioni.", "page-index-get-started-eth-image-alt": "Illustrazione di un gruppo di persone che contemplano incantate un glifo di ether (ETH).", "page-index-get-started-dapps-title": "Utilizzare una dapp", - "page-index-get-started-dapps-description": "Le dapp sono applicazioni alimentate da Ethereum. Scopri cosa ti permettono di fare.", - "page-index-get-started-dapps-image-alt": "Illustrazione di un cane che usa un computer.", + "page-index-get-started-dapps-description": "Le dapp sono applicazioni basate su Ethereum. Scopri cosa ti permettono di fare.", + "page-index-get-started-dapps-image-alt": "Illustrazione di un cane di razza doge, che utilizza un computer.", "page-index-get-started-devs-title": "Inizia a sviluppare", - "page-index-get-started-devs-description": "Se vuoi iniziare a programmare con Ethereum, abbiamo documentazione, tutorial e altro nel nostro portale sviluppatori.", - "page-index-get-started-devs-image-alt": "Illustrazione di una mano che crea il logo ETH con mattoncini Lego.", + "page-index-get-started-devs-description": "Se vuoi iniziare a programmare con Ethereum, abbiamo documentazione, tutorial e altro nel nostro portale per sviluppatori.", + "page-index-get-started-devs-image-alt": "Un'illustrazion di una mano, che crea un logo di ETH, realizzato con mattoncini Lego.", "page-index-what-is-ethereum": "Cos'è Ethereum?", - "page-index-what-is-ethereum-description": "Ethereum è una tecnologia che ospita denaro digitale, pagamenti globali e applicazioni. La comunità di creatori ha costruito un'economia digitale in forte espansione, modi innovativi e audaci per guadagnare online e molto altro ancora. È aperta a tutti e ovunque nel mondo, tutto ciò che serve è una connessione Internet.", + "page-index-what-is-ethereum-description": "Ethereum è una tecnologia che ospita denaro digitale, pagamenti globali e applicazioni. La community di creatori ha costruito un'economia digitale in forte espansione, metodi innovativi e audaci per guadagnare online e molto altro ancora. È aperta a tutti, in tutto il mondo: tutto ciò che serve è una connessione a Internet.", "page-index-what-is-ethereum-button": "Cos'è Ethereum?", - "page-index-what-is-ethereum-secondary-button": "Maggiori informazioni sul denaro digitale", - "page-index-what-is-ethereum-image-alt": "Illustrazione di una persona che sbircia in un bazar, che rappresenta Ethereum.", + "page-index-what-is-ethereum-secondary-button": "Di più sul denaro digitale", + "page-index-what-is-ethereum-image-alt": "Illustrazione di una persona che sbircia in un bazar, a rappresentare Ethereum.", "page-index-defi": "Un sistema finanziario più equo", "page-index-defi-description": "Oggi, miliardi di persone non hanno la possibilità di aprire conti bancari o vedono i propri pagamenti bloccati. Il sistema di finanza decentralizzata (DeFi) di Ethereum non dorme mai, né discrimina. Semplicemente con una connessione a Internet, puoi inviare, ricevere, prestare, guadagnare interessi e persino trasmettere fondi in tutto il mondo.", "page-index-defi-button": "Esplora la DeFi", "page-index-defi-image-alt": "Illustrazione di mani che offrono un simbolo ETH.", - "page-index-internet": "Un internet aperto", - "page-index-internet-description": "Oggi abbiamo accesso a servizi Internet \"gratuiti\" rinunciando al controllo dei nostri dati personali. I servizi Ethereum sono aperti per impostazione predefinita: tutto ciò di cui hai bisogno è un wallet. È gratuito e facile da configurare, lo controlli autonomamente e funziona senza alcuna informazione personale.", + "page-index-internet": "Un Internet aperto", + "page-index-internet-description": "Oggi, accediamo a servizi Internet \"liberi\", rinunciando al controllo dei nostri dati personali. I servizi di Ethereum sono aperti per definizione: tutto ciò di cui hai bisogno è un portafoglio. Questi, sono gratuiti e facili da configurare, controllati da te e funzionano senza alcuna informazione personale.", "page-index-internet-button": "Esplora l'Internet aperto", "page-index-internet-secondary-button": "Maggiori informazioni sui portafogli", - "page-index-internet-image-alt": "Illustrazione di un computer futuristico alimentato da cristalli Ethereum.", + "page-index-internet-image-alt": "Illustrazione di un computer futuristico alimentato da cristalli di Ethereum.", "page-index-developers": "Una nuova frontiera per lo sviluppo", - "page-index-developers-description": "Ethereum e le sue applicazioni sono trasparenti e open source. È possibile eseguire un codice fork e riutilizzare funzionalità già costruite da altri. Se non vuoi imparare un nuovo linguaggio, puoi semplicemente interagire con il codice open source utilizzando JavaScript e altri linguaggi esistenti.", + "page-index-developers-description": "Ethereum e le sue app, sono trasparenti e open source. Puoi biforcare il codice e riutilizzare funzionalità create da altri. Se non desideri imparare un nuovo linguaggio, puoi semplicemente interagire con il codice open source, utilizzando JavaScript e altri linguaggi esistenti.", "page-index-developers-button": "Portale per sviluppatori", "page-index-developers-code-examples": "Esempi di codice", "page-index-developers-code-example-title-0": "La tua banca", - "page-index-developers-code-example-description-0": "Puoi costruire una banca gestita dalla logica che hai programmato.", + "page-index-developers-code-example-description-0": "Puoi creare una banca, gestita dalla logica che hai programmato.", "page-index-developers-code-example-title-1": "La tua valuta", - "page-index-developers-code-example-description-1": "Puoi creare token da trasferire e utilizzare tra le applicazioni.", - "page-index-developers-code-example-title-2": "Un portafoglio di Ethereum in JavaScript", - "page-index-developers-code-example-description-2": "È possibile utilizzare i linguaggi esistenti per interagire con Ethereum e altre applicazioni.", + "page-index-developers-code-example-description-1": "Puoi creare token, trasferibili e utilizzabili tra più applicazioni.", + "page-index-developers-code-example-title-2": "Un portafoglio di Ethereum, programmato in JavaScript", + "page-index-developers-code-example-description-2": "Puoi utilizzare dei linguaggi esistenti, per interagire con Ethereum e altre applicazioni.", "page-index-developers-code-example-title-3": "Un DNS aperto e senza permessi", - "page-index-developers-code-example-description-3": "È possibile ripensare i servizi esistenti come applicazioni decentralizzate e aperte.", + "page-index-developers-code-example-description-3": "Puoi reimmaginare servizi esistenti, come applicazioni decentralizzate e aperte.", "page-index-network-stats-title": "Ethereum oggi", - "page-index-network-stats-subtitle": "Gli ultimi dati sulla rete", - "page-index-network-stats-total-eth-staked": "ETH in staking totali", + "page-index-network-stats-subtitle": "Le più recenti statistiche sulla rete", "page-index-network-stats-eth-price-description": "Prezzo di ETH (USD)", - "page-index-network-stats-eth-price-explainer": "L'ultimo prezzo per 1 ether. È possibile acquistare un minimo di 0,000000000000000001, senza bisogno di acquistare 1 ETH intero.", - "page-index-network-stats-tx-day-description": "Transazioni di oggi", - "page-index-network-stats-tx-day-explainer": "Il numero di transazioni elaborate con successo sulla rete nelle ultime 24 ore.", + "page-index-network-stats-eth-price-explainer": "Il prezzo più recente per 1 ether. Puoi acquistarne un minimo di 0,000000000000000001, non necessiti di acquistare 1 intero ETH.", + "page-index-network-stats-tx-day-description": "Le transazioni, oggi", + "page-index-network-stats-tx-day-explainer": "Il numero di transazioni elaborate con successo sulla rete, nelle ultime 24 ore.", "page-index-network-stats-value-defi-description": "Valore bloccato nella DeFi (USD)", - "page-index-network-stats-value-defi-explainer": "La quantità di denaro nelle applicazioni di finanza decentralizzata (DeFi), l'economia digitale di Ethereum.", + "page-index-network-stats-value-defi-explainer": "L'importo di denaro nelle applicazioni di finanza decentralizzata (DeFi), l'economia digitale di Ethereum.", "page-index-network-stats-nodes-description": "Nodi", "page-index-network-stats-nodes-explainer": "Ethereum è gestito da migliaia di volontari in tutto il mondo, noti come nodi.", "page-index-touts-header": "Esplora ethereum.org", "page-index-contribution-banner-title": "Contribuisci a ethereum.org", - "page-index-contribution-banner-description": "Questo è un sito open source con centinaia di collaboratori all'interno della comunità. Puoi proporre modifiche a qualsiasi contenuto del sito, suggerire nuove e fantastiche funzionalità o aiutarci a risolvere i bug.", - "page-index-contribution-banner-image-alt": "Un logo Ethereum fatto di mattoncini Lego.", + "page-index-contribution-banner-description": "Questo sito web è open source, con centinaia di collaboratori della community. Puoi proporre modifiche a qualsiasi contenuto su questo sito, suggerire nuove e fantastiche funzionalità, o aiutarci a risolvere i bug.", + "page-index-contribution-banner-image-alt": "Un logo di Ethereum, composto da mattoncini Lego.", "page-index-contribution-banner-button": "Maggiori informazioni sul contributo", "page-index-tout-upgrades-title": "Aumenta il livello delle tue conoscenze sugli aggiornamenti", "page-index-tout-upgrades-description": "La tabella di marcia di Ethereum consiste in aggiornamenti interconnessi, progettati per rendere la rete più scalabile, sicura e sostenibile.", - "page-index-tout-upgrades-image-alt": "Illustrazione di un'astronave che rappresenta l'incremento di potenza successivo agli aggiornamenti di Ethereum.", + "page-index-tout-upgrades-image-alt": "Illustrazione di un'astronave, rappresentante l'incremento di potenza, successivo agli aggiornamenti di Ethereum.", "page-index-tout-enterprise-title": "Ethereum per le imprese", - "page-index-tout-enterprise-description": "Scopri come Ethereum può aprire la strada a nuovi modelli di business, ridurre i costi e preparare la tua azienda per le sfide del futuro.", + "page-index-tout-enterprise-description": "Scopri come Ethereum può aprire la strada a nuovi modelli aziendali, ridurre i costi e preparare la tua azienda per le sfide future.", "page-index-tout-enterprise-image-alt": "Illustrazione di un computer/dispositivo futuristico.", "page-index-tout-community-title": "La community Ethereum", - "page-index-tout-community-description": "Ethereum è tutto incentrato sulla comunità. È composto da persone di diversa estrazione e interessi. Guarda come puoi partecipare.", - "page-index-tout-community-image-alt": "Illustrazione di un gruppo di costruttori che lavorano insieme.", + "page-index-tout-community-description": "Ethereum è completamente incentrato sulla community. Si compone di persone da diversi contesti e con interessi diversi. Scopri come puoi partecipare.", + "page-index-tout-community-image-alt": "Illustrazione di un gruppo di costruttori che collaborano.", "page-index-nft": "L'Internet delle risorse", - "page-index-nft-description": "Ethereum non si limita al denaro digitale. Qualunque bene o valore può essere rappresentato, scambiato e utilizzato sotto forma di token non fungibili (NFT). Puoi tokenizzare le tue opere d'arte e ottenere le royalty automaticamente ogni volta che vengono rivendute, oppure utilizzare un token connesso a qualcosa che possiedi per ottenere un prestito. Le possibilità sono in continua espansione.", + "page-index-nft-description": "Ethereum non si limita al denaro digitale. Qualsiasi cosa tu possa possedere, è rappresentabile, scambiabile e utilizzabile, nella forma di token non fungibili (NFT). Puoi tokenizzare le tue opere d'arte e ricevere automaticamente i diritti d'autore, ogni volta che sono rivendute. Oppure, puoi utilizzare un token per qualcosa che possiedi, per ottenere un prestito. Le possibilità sono in continua espansione.", "page-index-nft-button": "Maggiori informazioni sui NFT", "page-index-nft-alt": "Un logo Eth visualizzato tramite ologramma." } diff --git a/src/intl/it/page-languages.json b/src/intl/it/page-languages.json index 5961385888d..b2eb3b19499 100644 --- a/src/intl/it/page-languages.json +++ b/src/intl/it/page-languages.json @@ -1,16 +1,16 @@ { "page-languages-h1": "Supporto linguistico", - "page-languages-interested": "Ti interessa contribuire?", + "page-languages-interested": "Sei interessato a contribuire?", "page-languages-learn-more": "Scopri di più sul nostro Programma di Traduzione", "page-languages-meta-desc": "Risorse per tutte le lingue supportate di ethereum.org e modi per partecipare come traduttore.", - "page-languages-meta-title": "Traduzioni della Lingua di ethereum.org", - "page-languages-p1": "Ethereum è un progetto globale ed è fondamentale che ethereum.org sia accessibile per tutti, indipendentemente dalla loro nazionalità o lingua. La nostra community sta lavorando sodo per rendere questa visione una realtà.", + "page-languages-meta-title": "Traduzioni di ethereum.org", + "page-languages-p1": "Ethereum è un progetto globale, ed è fondamentale che sia accessibile per tutti, indipendentemente da nazionaliità o lingua. La nostra community sta lavorando sodo per rendere questa visione una realtà.", "page-languages-translations-available": "ethereum.org è disponibile nelle seguenti lingue", "page-languages-resources-paragraph": "Oltre a tradurre il contenuto di ethereum.org, manteniamo anche un", "page-languages-resources-link": "curato elenco di risorse di Ethereum in molte lingue", "page-languages-want-more-header": "Vuoi vedere ethereum.org in un'altra lingua?", "page-languages-want-more-link": "Programma di Traduzione", - "page-languages-want-more-paragraph": "I traduttori di ethereum.org traducono continuamente le pagine in quante più lingue possibile. Per vedere a cosa stanno lavorando al momento o per iscriversi per unirsi a loro, leggi del nostro", + "page-languages-want-more-paragraph": "I traduttori di ethereum.org traducono continuamente le pagine, in quante più lingue possibili. Per scoprire a cosa stanno lavorando al momento, o per unirsi a loro, leggi riguardo il nostro", "page-languages-filter-placeholder": "Filtro", "language-ar": "Arabo", "language-az": "Azero", @@ -28,6 +28,7 @@ "language-fr": "Francese", "language-gl": "Galiziano", "language-gu": "Gujarati", + "language-he": "Ebraico", "language-hi": "Hindi", "language-hr": "Croato", "language-hu": "Ungherese", @@ -45,7 +46,8 @@ "language-ms": "Malese", "language-nb": "Norvegese", "language-nl": "Olandese", - "language-fil": "Filippino", + "language-pcm": "Pidgin Nigeriano", + "language-ph": "Filippino", "language-pl": "Polacco", "language-pt": "Portoghese", "language-pt-br": "Portoghese (Brasile)", diff --git a/src/intl/it/page-layer-2.json b/src/intl/it/page-layer-2.json index 4d9711c8921..60e298c7001 100644 --- a/src/intl/it/page-layer-2.json +++ b/src/intl/it/page-layer-2.json @@ -1,129 +1,129 @@ { - "layer-2-arbitrum-note": "A prova di frode solo per gli utenti in whitelist, whitelist non ancora aperta", + "layer-2-arbitrum-note": "Prove di frode solo per gli utenti in lista bianca, non ancora aperta", "layer-2-boba-note": "Validazione dello stato in sviluppo", - "layer-2-optimism-note": "Prove di errore in sviluppo", + "layer-2-optimism-note": "Prove di contestazione in sviluppo", "layer-2-hero-title": "Livello 2", "layer-2-hero-header": "Ethereum per tutti", - "layer-2-hero-subtitle": "Scalare Ethereum senza compromettere la sicurezza né la decentralizzazione.", - "layer-2-hero-alt-text": "Illustrazione relativa alle transazioni che vengono svolte sul livello 2 e postate sulla rete principale Ethereum", + "layer-2-hero-subtitle": "Ridimensionare Ethereum senza compromettere la sicurezza o la decentralizzazione.", + "layer-2-hero-alt-text": "Illustrazione di transazioni raggruppate sul Livello 2 e pubblicate sulla Rete Principale di Ethereum", "layer-2-hero-button-1": "Cos'è il livello 2", - "layer-2-hero-button-2": "Usa il livello 2", + "layer-2-hero-button-2": "Utilizzare il livello 2", "layer-2-hero-button-3": "Spostarsi al livello 2", "layer-2-statsbox-1": "TVL bloccato nel livello 2 (USD)", - "layer-2-statsbox-2": "Commissione di trasferimento media in ETH nel livello 2 (USD)", - "layer-2-statsbox-3": "Variazione TVL livello 2 (30 giorni)", + "layer-2-statsbox-2": "Commissione di trasferimento media di ETH nel livello 2 (USD)", + "layer-2-statsbox-3": "Variazione di TVL sul livello 2 (30 giorni)", "layer-2-what-is-layer-2-title": "Cos'è il livello 2?", - "layer-2-what-is-layer-2-1": "Livello 2 (L2) è un termine collettivo per descrivere una serie specifica di soluzioni di ridimensionamento di Ethereum. Un livello 2 è una blockchain separata che estende Ethereum e ne eredita le garanzie di sicurezza.", - "layer-2-what-is-layer-2-2": "Ora daremo uno sguardo più in profondità e, per farlo, dobbiamo spiegare il livello 1 (L1).", + "layer-2-what-is-layer-2-1": "Livello 2 (L2), è un termine collettivo per descrivere una serie specifica di soluzioni di ridimensionamento di Ethereum. Un livello 2 è una blockchain separata che estende Ethereum e ne eredita le garanzie di sicurezza.", + "layer-2-what-is-layer-2-2": "Ora, approfondiremo e, per farlo, dobbiamo spiegare il livello 1 (L1).", "layer-2-what-is-layer-1-title": "Cos'è il livello 1?", - "layer-2-what-is-layer-1-1": "Il Livello 1 è la blockchain di base. Ethereum e Bitcoin sono entrambe blockchain di livello 1 perché sono le fondamenta sottostanti su cui si costruiscono varie reti di livello 2. Esempi di progetti di livello 2 includono i \"rollup\" su Ethereum e la Lightning Network su Bitcoin. Tutta l'attività delle transazioni degli utenti su questi progetti di livello 2 può infine tornare alla blockchain di livello 1.", - "layer-2-what-is-layer-1-2": "Ethereum opera anche come un livello di disponibilità dei dati per i livelli 2. I progetti di livello 2 pubblicheranno i propri dati delle transazioni su Ethereum, basandosi su Ethereum per la disponibilità dei dati. Questi dati sono utilizzabili per ottenere lo stato del livello 2, o per contestare le transazioni nel livello 2.", - "layer-2-what-is-layer-1-list-title": "Ethereum come sul livello 1 include:", - "layer-2-what-is-layer-1-list-1": "Una rete di operatori di nodi per proteggere e validare la rete", + "layer-2-what-is-layer-1-1": "Il Livello 1 è la blockchain di base. Ethereum e Bitcoin sono entrambe blockchain di livello 2, poiché sono le fondamenta sottostanti, su cui si basano le varie reti di livello 2. Esempi di progetti di livello 2 includono i \"rollup\" su Ethereum e la Lightning Network su Bitcoin. Tutte le attività di transazione degli utenti su tali progetti di livello 2, possono infine tornare alla blockchain di livello 1.", + "layer-2-what-is-layer-1-2": "Inoltre, Ethereum opera da livello di disponibilità dei dati per i livelli 2. I progetti di Livello 2 pubblicheranno i dati delle proprie transazioni su Ethereum, affidandosi a esso per la disponibilità dei dati. Questi dati, sono utilizzabili per ottenere lo stato del livello 2, o contestarne le transazioni.", + "layer-2-what-is-layer-1-list-title": "Ethereum, in qualità di livello 1, include:", + "layer-2-what-is-layer-1-list-1": "Una rete di operatori dei nodi per proteggere e convalidare la rete", "layer-2-what-is-layer-1-list-2": "Una rete di produttori di blocchi", "layer-2-what-is-layer-1-list-3": "La blockchain stessa e lo storico dei dati delle transazioni", "layer-2-what-is-layer-1-list-4": "Il meccanismo di consenso per la rete", - "layer-2-what-is-layer-1-list-link-1": "Ancora confuso su Ethereum?", + "layer-2-what-is-layer-1-list-link-1": "Ancora confusi su Ethereum?", "layer-2-what-is-layer-1-list-link-2": "Scopri cos'è Ethereum.", - "layer-2-why-do-we-need-layer-2-title": "Perché abbiamo bisogno del livello 2?", - "layer-2-why-do-we-need-layer-2-1": "Tre proprietà desiderabili di una blockchain sono che essa è decentralizzata, sicura e scalabile. Il trilemma della blockchain afferma che un'architettura semplice della blockchain può ottenerne solo due di queste tre proprietà. Vuoi una blockchain sicura e decentralizzata? Devi sacrificare la scalabilità.", - "layer-2-why-do-we-need-layer-2-2": "Ethereum ha raggiunto la capacità di rete corrente con oltre 1 milione di transazioni al giorno e un'elevata domanda per ognuna di queste transazioni. Il successo di Ethereum e la sua domanda, ha causato il sostanziale aumento dei prezzi del gas. Dunque, anche la necessità di delle soluzioni di ridimensionamento è aumentata in domanda. È qui che entrano in gioco le reti di livello 2.", + "layer-2-why-do-we-need-layer-2-title": "Perché necessitiamo del livello 2?", + "layer-2-why-do-we-need-layer-2-1": "Tre proprietà desiderabili di una blockchain, sono che sia decentralizzata, sicura e scalabile. Il trilemma della blockchain afferma che un'architettura semplice della blockchain possa ottenere soltanto due delle tre. Desideri una blockchain sicura e decentralizzata? Dovrai sacrificarne la scalabilità.", + "layer-2-why-do-we-need-layer-2-2": "Ethereum ha raggiunto la capacità di rete attuale con oltre 1 milione di transazioni al giorno e un'elevata domanda per ognuna di esse. Il successo di Ethereum e la sua domanda, hanno causato l'aumento sostanziale dei prezzi del gas. Dunque, è aumentata anche la domanda per necessità di soluzioni di ridimensionamento. È qui che entrano in gioco le reti di livello 2.", "layer-2-why-do-we-need-layer-2-scalability": "Scalabilità", - "layer-2-why-do-we-need-layer-2-scalability-1": "L'obiettivo principale della scalabilità è aumentare la velocità di transazione (finalità di una maggiore velocità) e il volume delle transazioni (più transazioni al secondo), senza sacrificare la decentralizzazione o la sicurezza.", - "layer-2-why-do-we-need-layer-2-scalability-2": "La community di Ethereum ha preso una forte posizione, impegnandosi a non compromettere la decentralizzazione o la sicurezza per scalare. Fino alla frammentazione, la Rete Principale di Ethereum (livello 1) è capace di elaborare solo approssimativamente 15 transazioni al secondo. Quando la domanda di usare Ethereum è elevata, la rete si congestiona, aumentando le commissioni di transazione ed escludendo gli utenti che non possono permettersi tali commissioni. È qui che oggi entra in gioco il livello 2 per scalare Ethereum.", - "layer-2-why-do-we-need-layer-2-scalability-3": "Approfondisci la visione di Ethereum", + "layer-2-why-do-we-need-layer-2-scalability-1": "L'obiettivo principale della scalabilità è aumentare la velocità delle transazioni (finalità più veloce) e il volume delle transazioni (più transazioni al secondo), senza sacrificare la decentralizzazione o la sicurezza.", + "layer-2-why-do-we-need-layer-2-scalability-2": "La community di Ethereum ha preso una forte posizone, relativamente al non ridurre la decentralizzazione o la sicurezza, per poter ridimensionare. Fino alla frammentazione, la Rete Principale di Ethereum (livello 1), può elaborare soltanto approssimativamente 15 transazioni al secondo. Quando la domanda di utilizzo di Ethereum è elevata, la rete si congestiona, incrementando le commissioni sulle transazioni e deprezzando gli utenti che non possono permettersi tali commissioni. È qui che, oggi, entra in gioco il livello 2, per ridimensionare Ethereum.", + "layer-2-why-do-we-need-layer-2-scalability-3": "Di più sulla visione di Ethereum", "layer-2-benefits-of-layer-2-title": "Benefici del livello 2", "layer-2-lower-fees-title": "Commissioni più basse", - "layer-2-lower-fees-description": "Combinando molteplici transazioni fuori dalla catena (off-chain) in una singola transazione di livello 1, le commissioni di transazione calano notevolmente, rendendo Ethereum più accessibile per tutti.", + "layer-2-lower-fees-description": "Combinando più transazioni esterne alla catena in una singola transazione del livello 1, le commissioni di transazione sono ridotte enormemente, rendendo Ethereum più accessibile per tutti.", "layer-2-maintain-security-title": "Mantenere la sicurezza", - "layer-2-maintain-security-description": "Le blockchain di livello 2 regolano le proprie transazioni sulla rete principale Ethereum, consentendo agli utenti di poter beneficiare della sicurezza della rete Ethereum.", - "layer-2-expand-use-cases-title": "Espandi i casi d'uso", - "layer-2-expand-use-cases-description": "Con più transazioni al secondo, basse commissioni, e una nuova tecnologia, i progetti si espanderanno in nuove applicazioni con una migliore esperienza utente.", - "layer-2-how-does-layer-2-work-title": "Come funzione il livello 2?", - "layer-2-how-does-layer-2-work-1": "Come menzionato sopra, il Livello 2 è un termine collettivo per le soluzioni di scaling di Ethereum che gestiscono le transazioni al di fuori del livello 1 di Ethereum, avvantaggiandosi comunque della robusta sicurezza decentralizzata del livello 1 di Ethereum. Un livello 2 è una blockchain separata che estende Ethereum. Come funziona?", - "layer-2-how-does-layer-2-work-2": "Una blockchain di livello 2 comunica regolarmente con Ethereum (inviando pacchetti di transazioni) per garantire che abbia garanzie di sicurezza e decentralizzazione simili. Tutto ciò non richiede modifiche al protocollo di livello 1 (Ethereum). Questo consente al livello 1 di gestire la sicurezza, la disponibilità dei dati e la decentralizzazione; mentre il livello 2 gestisce lo scaling. I livelli 2 tolgono del carico transazionale al livello 1 e pubblicano poi le prove finalizzate di nuovo nel livello 1. Rimuovendo questo carico di transazione dal livello 1, il livello di base diventa meno congestionato e tutto diventa più scalabile.", + "layer-2-maintain-security-description": "Le blockchain di livello 2 regolano le proprie transazioni sulla Rete Principale di Ethereum, consentendo agli utenti di beneficiare della sicurezza della rete di Ethereum.", + "layer-2-expand-use-cases-title": "Espandere i casi d'uso", + "layer-2-expand-use-cases-description": "Con più transazioni al secondo, commissioni ridotte e nuove tecnologie, i progetti si espanderanno in applicazioni, con una migliore esperienza per gli utenti.", + "layer-2-how-does-layer-2-work-title": "Come funziona il livello 2?", + "layer-2-how-does-layer-2-work-1": "Come menzionato sopra, Livello 2 è un termine collettivo per le soluzioni di ridimensionamento di Ethereum che gestiscono le transazioni al di fuori del livello 1 di Ethereum, pur avvantaggiandosi della sua robusta sicurezza decentralizzata. Un livello 2 è una blockchain separata che estende Ethereum. Ma come funziona?", + "layer-2-how-does-layer-2-work-2": "Una blockchain del livello 2 comunica regolarmente con Ethereum (inviando pacchetti di transazioni), per assicurarsi che abbia garanzie di sicurezza e decentralizzazione simili. Tutto ciò non richiede alcuna modifica al protocollo del livello 1 (Ethereum). Ciò consente al livello 1 di gestire la sicurezza, la disponibilità dei dati e la decentralizzazione, mentre i livelli 2 gestiscono il ridimensionamento. I Livelli 2 riducono il carico di transazioni del livello 1, ripubblicando le prove finalizzate sul livello 1. Rimuovendo tale carico di transazioni dal livello 1, si riduce la congestione del livello di base e tutto diviene più scalabile.", "layer-2-rollups-title": "Rollup", - "layer-2-rollups-1": "Correntemente, i rollup sono la soluzione di livello 2 preferita per ridimensionare Ethereum. Usando i rollup, gli utenti possono ridurre le commissioni sul gas fino a 100 volte, rispetto al livello 1.", - "layer-2-rollups-2": "I rollup impacchettano (avvolgono, \"roll up\" in inglese) centinaia di transazioni in una singola transazione sul livello 1. Questo distribuisce le commissioni di transazione del L1 tra tutti gli utenti nel rollup, rendendolo più economico per ogni utente. Le transazioni di rollup sono eseguite al di fuori del livello 1, ma i dati delle transazioni sono pubblicati nel livello 1. Pubblicando i dati delle transazioni sul livello 1, i rollup ereditano la sicurezza di Ethereum. Esistono due approcci differenti ai rollup: ottimistici e a conoscenza zero (zero-knowledge), che differiscono principalmente per il modo in cui questi dati delle transazioni sono pubblicati nel L1.", + "layer-2-rollups-1": "I rollup sono al momento la soluzione di livello 2 preferita per ridimensionare Ethereum. Utilizzandoli, gli utenti possono ridurre per fino a 100 volte le commissioni sul gas, rispetto al livello 1.", + "layer-2-rollups-2": "I rollup impacchettano centinaia di transazioni in una singola transazione sul livello 1. Ciò distribuisce le commissioni di transazione del L1 tra tutti i componenti del rollup, rendendole più economiche per ogni utente. Le transazioni raggruppate sono eseguite al di fuori del livello 1, ma i loro dati sono pubblicati su di esso. Pubblicando i dati di transazione sul livello 1, i rollup ereditano la sicurezza di Ethereum. Esistono due approcci differenti ai rollup: ottimistici e a conoscenza zero, che differiscono principalmente nel metodo di pubblicazione dei dati di transazione sul L1.", "layer-2-optimistic-rollups-title": "Rollup ottimistici", - "layer-2-optimistic-rollups-description": "I rollup ottimistici sono tali nel senso che presumono che le transazioni siano valide, ma possono essere contestate se necessario. Se si sospetta una transazione non valida, si esegue una prova di errore per verificare se è vi è stata una frode.", - "layer-2-optimistic-rollups-childSentance": "Approfondimento più sui rollup ottimistici", + "layer-2-optimistic-rollups-description": "I rollup ottimistici sono tali nel senso che presumono che le transazioni siano valide, ma ciò è contestabile se necessario. Se si sospetta che una transazione non sia valida, è eseguita una prova di contestazione, per verificare che non sia tale.", + "layer-2-optimistic-rollups-childSentance": "Di più sui rollup ottimistici", "layer-2-zk-rollups-title": "Rollup a conoscenza zero (zero-knowledge)", - "layer-2-zk-rollups-description": "I rollup a conoscenza zero usano le prove di validità in cui le transazioni vengono calcolate al di fuori della catena e forniscono poi i dati compressi alla rete principale di Ethereum come prova della loro validità.", - "layer-2-zk-rollups-childSentance": "Maggiori informazioni sui rollup ZK", + "layer-2-zk-rollups-description": "I rollup a conoscenza zero utilizzano le prove di validità, in cui le transazioni sono calcolate all'esterno della catena, quindi, i dati compressi sono forniti alla Rete Principale di Ethereum, come prova della loro validità.", + "layer-2-zk-rollups-childSentance": "Di più sui rollup ZK", "layer-2-dyor-title": "Fai delle verifiche: i rischi del livello 2", - "layer-2-dyor-1": "Poiché le catene di livello 2 ereditano la sicurezza da Ethereum, in un mondo ideale, sono sicure quanto Ethereum di L1. Tuttavia, molti progetti sono ancora giovani e in qualche modo sperimentali. Dopo anni di ricerca e sviluppo, nel 2021 sono state lanciate molte tecnologie L2 per lo scaling di Ethereum. Molti progetti si basano ancora su presupposti di fiducia, mentre lavorano per decentralizzare le proprie reti. Fai sempre delle verifiche per decidere se accettare gli eventuali rischi connessi.", - "layer-2-dyor-2": "Per ulteriori informazioni sulla tecnologia, i rischi e i presupposti di fiducia dei livelli 2, consigliamo di dare un'occhiata a L2BEAT, che fornisce un quadro di valutazione completo dei rischi di ogni progetto.", + "layer-2-dyor-1": "Poiché le catene di livello 2 ereditano la sicurezza da Ethereum, in un mondo ideale, sono sicure quanto il L1 di Ethereum. Tuttavia, molti dei progetti sono ancora giovani e sperimentali. Dopo anni di ricerca e sviluppo, molte delle tecnologie del L2 che ridimensioneranno Ethereum, sono state lanciate nel 2021. Molti progetti includono ancora ipotesi di fiducia aggiuntive, operando per decentralizzare le proprie reti. Fai sempre le tue ricerche per decidere se sei a tuo agio con qualsiasi possibile rischio.", + "layer-2-dyor-2": "Per ulteriori informazioni sulla tecnologia, i rischi e le ipotesi di fiducia dei livelli 2, consigliamo di consultare L2BEAT, che fornisce un quadro completo di valutazione dei rischi di ogni progetto.", "layer-2-dyor-3": "Vai a L2BEAT", "layer-2-use-layer-2-title": "Usa il livello 2", - "layer-2-use-layer-2-1": "Adesso che hai capito perché esiste il livello 2 e come funziona, inizia ad operare!", - "layer-2-contract-accounts": "NOTA: Eseguendo un collegamento e utilizzando il livello 2, è importante notare che controllerai l'indirizzo del tuo conto EOA (un conto controllato da una singola chiave privata), proprio come sulla Rete Principale di Ethereum. Se invece stai utilizzando il conto di un contratto, come Safe o Argent, non avrai il controllo su quell’indirizzo su un livello 2 finché non ridistribuirai il conto del tuo contratto a quell’indirizzo sul livello 2. Se stai effettuando un collegamento o stai inviando fondi al conto di un contratto e non hai il controllo su questo indirizzo del conto del contratto, i tuoi fondi potrebbero andare persi.", + "layer-2-use-layer-2-1": "Ora che comprendi perché i livelli 2 esistono e come funzionno, inizia a familiarizzare!", + "layer-2-contract-accounts": "NOTA: Collegandoti e utilizzando il livello 2, è importante notare che controllerai l'indirizzo per il tuo conto EOA (un conto in cui una singola chiave privata controlla tutto), proprio come sulla Rete Principale di Ethereum. Tuttavia, se stai utilizzando il conto di un contraatto, come Safe o Argent, non avrai il controllo su tale indirizzo su un livello 2, fino aalla ridistribuzione del conto del tuo contratto a tale indirizzo, sul livello 2. Se ti stai collegando con o inviando fondi al conto di un contratto, e non controlli questo indirizzo per il conto del contratto, i tuoi fondi potrebbero andare perduti.", "layer-2-use-layer-2-generalized-title": "Livelli 2 generalizzati", - "layer-2-use-layer-2-generalized-1": "I livelli 2 generalizzati si comportano proprio come Ethereum, ma sono più economici. Qualsiasi cosa tu possa fare sul livello 1 di Ethereum, puoi farlo anche sul livello 2. Molte dapp hanno già iniziato a migrare verso queste reti o hanno saltato la rete principale nel complesso per distribuire direttamente su un livello 2.", + "layer-2-use-layer-2-generalized-1": "I livelli 2 generalizzati si comportano come Ethereum, ma sono più economici. Tutto ciò che puoi fare sul livello 1 di Ethereum, puoi farlo anche sul livello 2. Molte dapp hanno già iniziato a migrare a queste reti o hanno saltato la Rete Principale, per essere direttamente distribuite su un livello 2.", "layer-2-use-layer-2-application-specific-title": "Livelli 2 specifici dell'applicazione", - "layer-2-use-layer-2-application-specific-1": "I livelli 2 specifici dell'applicazione sono progetti che si specializzano nell'ottimizzazione dello spazio specifico di un'applicazione, migliorando così le prestazioni.", - "layer-2-sidechains-title": "Una nota su catene secondarie, validium e blockchain alternative", - "layer-2-sidechains-1": "Le catene secondarie e i validium sono blockchain che consentono alle risorse provenienti da Ethereum di varcare i confini ed essere usate su un'altra blockchain. Le catene secondarie e i validium sono eseguiti in parallelo con Ethereum e interagiscono con esso tramite i ponti, ma non ne ereditano la sicurezza o la disponibilità dei dati.", - "layer-2-sidechains-2": "Entrambi scalano similmente ai livelli 2: offrono minori commissioni di transazione e maggiore volume di transazione, ma hanno presupposti di fiducia differenti.", - "layer-2-more-on-sidechains": "Maggiori informazioni sulle catene secondarie", - "layer-2-more-on-validiums": "Maggiori informazioni sui validium", - "layer-2-sidechains-4": "Alcune blockchain di livello 1 hanno un volume maggiore e commissioni di transazione inferiori a Ethereum. Questi livelli 1 alternativi hanno dovuto sacrificare la sicurezza o la decentralizzazione per potere ottenere maggiori transazioni al secondo e ridurre le commissioni di transazione.", - "layer-2-sidechains-5": "L'ecosistema di Ethereum è fermamente allineato sul fatto che lo scaling al livello 2 è l'unico modo per risolvere il trilemma di scalabilità, pur rimanendo decentralizzazione e sicurezza.", + "layer-2-use-layer-2-application-specific-1": "I livelli 2 specifici dell'applicazione sono progetti specalizzati nell'ottimizzazione per uno spazio d'applicazione specifico, comportando migliori prestazioni.", + "layer-2-sidechains-title": "Una nota su catene secondarie, Validium e blockchain alternative", + "layer-2-sidechains-1": "Le catene secondarie e i Validium sono blockchain che consentono il collegamento di risorse da Ethereum e il loro utilizzo su un'altra blockchain. Le catene secondarie e i Validium operano in parallelo con Ethereum, e vi interagiscono tramite i ponti, ma non ne derivano la sicurezza o la disponibilità dei dati.", + "layer-2-sidechains-2": "Entrambi scalano similmente ai livelli 2: offrono commissioni di transazione ridotte e volumi di transazione maggiori, ma hanno ipotesi di fiducia differenti.", + "layer-2-more-on-sidechains": "Di più sulle catene secondarie", + "layer-2-more-on-validiums": "Di più sui Validium", + "layer-2-sidechains-4": "Alcune blockchain di livello 1 hanno un volume maggiore e commissioni di transazione inferiori, rispetto a Ethereum. Questi livelli 1 alternativi hanno dovuto sacrificare la sicurezza o la decentralizzazione, per ottenere maggiori transazioni al secondo e commissioni di transazione ridotte.", + "layer-2-sidechains-5": "L'ecosistema di Ethereum è fermamente allineato sul fatto che Il ridimensionamento del livello 2 è il solo modo per risolvere il trilemma della scalabilità, rimanendo decentralizzato e sicuro.", "layer-2-onboard-title": "Come arrivare a un livello 2", - "layer-2-onboard-1": "Esistono due modi principali per portare le tue risorse su un livello 2: collegare i fondi da Ethereum tramite un contratto intelligente o prelevarli su una borsa, direttamente alla rete di livello 2.", + "layer-2-onboard-1": "Esistono due modi principali per portare le tue risorse su un livello 2: collegare i fondi da Ethereum tramite un contratto intelligente, o prelevarli su una piattaforma di scambio, direttamente sulla rete di livello 2.", "layer-2-onboard-wallet-title": "Fondi nel tuo portafoglio?", - "layer-2-onboard-wallet-1": "Se hai già i tuoi ETH nel tuo portafoglio, dovrai usare un ponte per spostarli dalla Rete Principale di Ethereum a un livello 2.", - "layer-2-more-on-bridges": "Maggiori informazioni sui ponti", - "layer-2-onboard-wallet-input-placeholder": "Seleziona il L2 verso cui effettuare il ponte", + "layer-2-onboard-wallet-1": "Se hai già i tuoi ETH nel tuo portafoglio, dovrai utilzzare un ponte per spostarli dalla Rete Principale di Ethereum a un livello 2.", + "layer-2-more-on-bridges": "Di più sui ponti", + "layer-2-onboard-wallet-input-placeholder": "Seleziona L2 verso cui vuoi collegarti", "layer-2-onboard-wallet-selected-1": "Puoi connetterti a", "layer-2-onboard-wallet-selected-2": "usando questi portafogli:", "layer-2-bridge": "Ponte", - "layer-2-onboard-exchange-title": "Fondi su una borsa?", - "layer-2-onboard-exchange-1": "Alcune borse centralizzate offrono ora prelievi e depositi diretti ai livelli 2. Verifica quali borse supportano i prelievi di livello 2 e quali livelli 2 supportano.", - "layer-2-onboard-exchange-2": "Avrai anche bisogno di un portafoglio da cui prelevare i tuoi fondi.", + "layer-2-onboard-exchange-title": "Fondi su una piattaforma di scambio?", + "layer-2-onboard-exchange-1": "Alcune piattaforme di scambio centralizzate, offrono ora prelievi e depositi ai livelli 2. Consulta quali piattaforme di scambio supportano i prelievi sul livello 2, e quali livelli 2 supportano.", + "layer-2-onboard-exchange-2": "Inoltre, necessiterai di un portafoglio su cui prelevare i tuoi fondi.", "layer-2-onboard-find-a-wallet": "Trova un portafoglio di Ethereum.", - "layer-2-onboard-exchange-input-placeholder": "Verifica le borse che supportano L2", + "layer-2-onboard-exchange-input-placeholder": "Consulta le piattaforme di scambio che supportano i L2", "layer-2-deposits": "Depositi", "layer-2-withdrawals": "Prelievi", "layer-2-go-to": "Vai a", "layer-2-tools-title": "Strumenti per essere efficienti sul livello 2", - "layer-2-tools-l2beat-description": "L2BEAT è un'ottima risorsa per esaminare le valutazioni di rischio tecnico dei progetti di livello 2. Consigliamo di verificare le loro risorse ricercando i progetti dello specifico livello 2.", - "layer-2-tools-l2fees-description": "Le commissioni del L2 ti consentono di vedere il costo corrente (denominato in USD) per effettuare le transazioni su diversi livelli 2.", - "layer-2-tools-chainlist-description": "Chainlist è un'ottima risorsa per importare RPC della rete nei portafogli che le supportano. Troverai le RPC per i progetti di livello 2 qui, per aiutarti a connetterti.", - "layer-2-tools-zapper-description": "Gestisci il tuo intero portafoglio web3, dalle DeFi agli NFT e qualsiasi altra cosa verrà in futuro. Investi nelle opportunità più recenti da un posto solo.", - "layer-2-tools-zerion-description": "Crea e gestisci il tuo intero portafoglio DeFi da un posto solo. Scopri il mondo della finanza decentralizzata oggi.", - "layer-2-tools-debank-description": "Tieniti aggiornato su tutti gli eventi importanti nel mondo web3", + "layer-2-tools-l2beat-description": "L2BEAT è un'ottima risorsa per esaminare le valutazioni di rischio tecnico dei progetti di livello 2. Consigliamo di consultarne le risorse, ricercando progetti di livello 2 specifici.", + "layer-2-tools-l2fees-description": "L2 Fees ti consente di consultare i costi attuali (in USD), per effettuare le transazioni su livelli 2 differenti.", + "layer-2-tools-chainlist-description": "Chainlist è un'ottima risorsa per importare la RPC della rete nei portafogli che la supportano. Qui, troverai le RPC per i progetti di livello 2, per aiutare a connetterti.", + "layer-2-tools-zapper-description": "Gestisci il tuo intero portfolio Web3, dalla DeFi ai NFT, e qualsiasi altra cosa verrà in futuro. Investi nelle opportunità più recenti da un singolo, comodo luogo.", + "layer-2-tools-zerion-description": "Crea e gestisci il tuo intero portfolio della DeFi da un singolo posto. Scopri oggi il mondo della finanza decentralizzata.", + "layer-2-tools-debank-description": "Tieni il passo con tutti gli eventi importanti nel mondo del Web3", "layer-2-faq-title": "Domande frequenti", - "layer-2-faq-question-1-title": "Perché non esiste un L2 di Ethereum \"ufficiale\"?", - "layer-2-faq-question-1-description-1": "Proprio come non esiste un client di Ethereum \"ufficiale\", non esiste alcun livello 2 di Ethereum \"ufficiale\". Ethereum non prevede permessi: tecnicamente chiunque può creare un livello 2! Diversi team implementeranno la propria versione di un livello 2 e l'ecosistema intero beneficerà di una diversità di approcci di design ottimizzati per diversi casi d'uso. Proprio come abbiamo diversi client di Ethereum sviluppati da diversi team per poter avere diversità nella rete, allo stesso modo si svilupperanno i livelli 2 in futuro.", + "layer-2-faq-question-1-title": "Perché non esiste un L2 \"ufficiale\" di Ethereum?", + "layer-2-faq-question-1-description-1": "Proprio come non esiste alcun client \"ufficiale\" di Ethereum, non esiste alcun livello 2 \"ufficiale\" di Ethereum. Ethereum è privo di permessi: tecnicamente, chiunque può creare un livello 2! Svariati team implementeranno la propria versione di un livello 2 e, l'ecosistema intero beneficierà da una diversità di approcci di progettazione, ottimizzati per casi d'uso differenti. Proprio come abbiamo numerosi client di Ethereum, sviluppati da numerosi teaam, per consentire la diversità nella rete, così saranno sviluppati i livelli 2 in futuro.", "layer-2-faq-question-2-title": "Qual è la differenza tra i rollup ottimistici e a conoscenza zero?", - "layer-2-faq-question-2-description-1": "Sia i rollup ottimistici che a conoscenza zero impacchettano (o \"avvolgono\") centinaia di transazioni in una sola transazione sul livello 1. Le transazioni di rollup sono eseguite al di fuori del livello 1, ma i dati delle transazioni sono pubblicati nel livello 1.", - "layer-2-faq-question-2-description-2": "La differenza principale consiste in quali dati sono pubblicati al livello 1 e come sono verificati i dati. Le prove di validità (usate dai rollup a conoscenza zero) eseguono i calcoli al di fuori della catena e pubblicano una prova, mentre le prove di errore (usate dai rollup ottimistici) eseguono i calcoli solo sulla catena, quando vi è un sospetto di errore che deve essere verificato.", - "layer-2-faq-question-2-description-3": "Al momento, gran parte dei rollup ZK sono specifici per le applicazioni, rispetto ai rollup ottimistici, che sono stati largamente generalizzabili.", - "layer-2-more-info-on-optimistic-rollups": "Maggiori informazioni sui rollup ottimistici", - "layer-2-more-info-on-zk-rollups": "Maggiori informazioni sui rollup a conoscenza zero (zero-knowledge)", + "layer-2-faq-question-2-description-1": "Sia i rollup ottimistici che quelli a conoscenza zero, raggruppano centinaia di transazioni in una singola transazione sul livello 1. Le transazioni di rollup sono eseguite all'esterno del livello 1, ma i loro dati sono pubblicati sul livello 1.", + "layer-2-faq-question-2-description-2": "La differenza principale consiste in quali dati sono pubblicati sul livello 1, e in come sono verificati i dati. Le prove di validità (utilizzate dai rollup a conoscenza zero), eseguono i calcoli all'esterno della catena e pubblicano una prova, mentre le prove di contestazione (utilizzate dai rollup ottimistici), eseguono i calcoli all'esterno della catena, soltanto quando si sospetta un errore e devono essere verificati.", + "layer-2-faq-question-2-description-3": "Al momento, gran parte dei rollup ZK sono specifici per le applicazioni, rispetto ai rollup ottimistici che sono stati largamente generalizzabili.", + "layer-2-more-info-on-optimistic-rollups": "Di più sui rollup ottimistici", + "layer-2-more-info-on-zk-rollups": "Di più sui rollup a conoscenza zero", "layer-2-faq-question-4-title": "Quali sono i rischi con il livello 2?", - "layer-2-faq-question-4-description-1": "I progetti di livello 2 presentano rischi aggiuntivi rispetto al possesso di fondi e alla conclusione di transazioni direttamente sulla rete principale di Ethereum. Ad esempio, i sequenziatori potrebbero smettere di funzionare, causando un ritardo nell'accesso ai fondi.", - "layer-2-faq-question-4-description-2": "Ti invitiamo fare delle verifiche prima di trasferire fondi significativi a un livello 2. Per ulteriori informazioni sulla tecnologia, i rischi e i presupposti di fiducia dei livelli 2, consigliamo di dare un'occhiata a L2BEAT, che fornisce un quadro di valutazione completo dei rischi di ogni progetto.", - "layer-2-faq-question-4-description-3": "I ponti della blockchain, che facilitano i trasferimenti di risorse al livello 2, sono nelle loro fasi iniziali di sviluppo ed è possibile che il design ottimale del ponte non sia ancora stato scoperto. Si sono verificate degli attacchi recenti ai ponti.", + "layer-2-faq-question-4-description-1": "I progetti di livello 2 presentano rischi aggiuntivi rispetto al possesso di fondi e allo svolgimento di transazioni direttamente sulla Rete Principale di Ethereum. Ad esempio, i sequenziatori potrebbero interrompersi, costringendoti ad attendere, per accedere ai fondi.", + "layer-2-faq-question-4-description-2": "Ti incoraggiamo a effettuare le tue ricerche, prima di trasferire fondi significativi a un livello 2. Per ulteriori informazioni sulla tecnologia, sui rischi e sulle ipotesi di fiducia dei livelli 2, suggeriamo di consultare L2BEAT, che fornisce un quadro completo di valutazione dei rischi di ogni progetto.", + "layer-2-faq-question-4-description-3": "I ponti della blockchain, che facilitano i trasferimenti di risorse al livello 2, sono nelle prime fasi di sviluppo ed è probabile che il design ottimale dei ponti non sia ancora stato scoperto. Di recente, si sono verificati degli attacchi ai ponti.", "layer-2-faq-question-5-title": "Perché alcuni progetti del livello 2 non sono elencati qui?", - "layer-2-faq-question-5-description-1": "Vogliamo assicurarci di elencare le migliori risorse possibili, così che gli utenti possano muoversi nello spazio del livello 2 in un modo sicuro e comodo. Manteniamo un quadro di criteri di valutazione dei progetti ai fini dell'inclusione.", - "layer-2-faq-question-5-view-listing-policy": "Visualizza qui la nostra politica di inserzione nel livello 2.", - "layer-2-faq-question-5-description-2": "Chiunque è libero di suggerire l'aggiunta di un livello 2 su ethereum.org. Se esiste un livello 2 che ci siamo persi, ti invitiamo di suggerirlo.", + "layer-2-faq-question-5-description-1": "Vogliamo assicurarci di elencare le migliori risorse possibili, così che gli utenti possano navigare per lo spazio di livello 2, in modo sicuro e comodo. Manteniamo un quadro di criteri per la valutazione dei progetti, per la loro inclusione.", + "layer-2-faq-question-5-view-listing-policy": "Visualizza qui la nostra politica di inserzione dei livelli 2.", + "layer-2-faq-question-5-description-2": "Chiunque è libero di suggerire l'aggiunta di un livello 2 su ethereum.org. Se esiste un livello 2 di cui ci siamo dimenticati, ti preghiamo di suggerirlo.", "layer-2-further-reading-title": "Lettura consigliate", "a-rollup-centric-ethereum-roadmap": "Una tabella di marcia di Ethereum incentrata sui rollup", "an-incomplete-guide-to-rollups": "Una guida incompleta ai rollup", - "polygon-sidechain-vs-ethereum-rollups": "Catena secondaria Polygon vs rollup di Ethereum: approcci allo scaling del Livello 2| Vitalik Buterin e Lex Fridman", - "rollups-the-ultimate-ethereum-scaling-strategy": "ROLLUP - La strategia definitiva di scaling di Ethereum? Arbitrum e Optimism Spiegati", - "scaling-layer-1-with-shard-chains": "Scaling del livello 1 con le catene di shard", + "polygon-sidechain-vs-ethereum-rollups": "Catena secondaria di Polygon vs. rollup di Ethereum: Approcci al ridimensionamento dei Livelli 2 | Vitalik Buterin e Lex Fridman", + "rollups-the-ultimate-ethereum-scaling-strategy": "ROLLUP: La strategia definitiva di ridimensionamento di Ethereum? Arbitrum e Optimism spiegati", + "scaling-layer-1-with-shard-chains": "Ridimensionare il livello 1 con le catene di frammenti", "understanding-rollup-economics-from-first-principals": "Comprendere l'economia dei rollup dalle basi", - "arbitrum-description": "Arbitrum è un Rollup Ottimistico che punta a dare la sensazione di interagire con Ethereum, ma con transazioni che costano una frazione di quanto costano sul L1.", - "optimism-description": "Optimism è un rollup ottimistico equivalente all'EVM veloce, semplice e sicuro. Scala la tecnologia di Ethereum ridimensionandone anche i valori tramite il finanziamento retroattivo di beni pubblici.", - "boba-description": "Boba è un Rollup Ottimistico, biforcato originariamente da Optimism, una soluzione di ridimensionamento mirata a ridurre le commissioni sul gas, migliorare il volume delle transazioni ed estendere le capacità dei contratti intelligenti.", - "loopring-description": "La soluzione di L2 zkRollup di Loopring mira a offrire le stesse garanzie di sicurezza della rete principale di Ethereum, con un grande aumento di scalabilità: volume aumentato del 1000x e costo ridotto allo 0,1% di L1.", - "zksync-description": "zkSync è una piattaforma di rollup zk incentrata sull'utente prodotta da Matter Labs. È una soluzione di scalabilità per Ethereum, già live sulla rete principale di Ethereum. Supporta pagamenti, scambi di token e conio di NFT.", - "zkspace-description": "La piattaforma di ZKSpace consiste in tre parti principali: una DEX AMM di Livello 2 che usa la tecnologia di Rollup ZK detta ZKSwap, un servizio di pagamento detto ZKSquare e un mercato di NFT detto ZKSea.", - "aztec-description": "Aztec Network è il primo rollup zk privato su Ethereum, che consente alle applicazioni decentralizzate di avere accesso alla privacy e di scalare.", + "arbitrum-description": "Arbitrum è un Rollup Ottimistico che mira a dare la sensazione di interagire con Ethereum, ma con costi delle transazioni pari a una frazione del costo sul L1.", + "optimism-description": "Optimism è un rollup ottimistico veloce, semplice e sicuro, equivalente a Ethereum. Ridimensiona la tecnologia di Ethereum, ridimensionandone i valori tramite il finanziamento retroattivo dei beni pubblici.", + "boba-description": "Boba è un Rollup Ottimistico, biforcato originariamente da Optimism; una soluzione di ridimensionamento che mira a ridurre le commissioni sul gas, migliorare il volume delle transazioni ed estendere le capacità dei contratti intelligenti.", + "loopring-description": "La soluzione di L2 zkRollup di Loopring mira a offrire le stesse garanzie di sicurezza della Rete Principale di Ethereum, con un grande incremento della scalabilità: volume incrementato di 1000 volte e costi ridotti allo 0,1% del L1.", + "zksync-description": "zkSync è una piattaforma di rollup ZK incentrata sugli utenti, di Matter Labs. È una soluzione di ridimensionamento per Ethereum, già attiva sulla sua Rete Principale. Supporta pagamenti, scambi di token e conio di NFT.", + "zkspace-description": "La piattaforma di ZKSpace consiste in tre parti principali: una DEX AMM di Livello 2 che utilizza la tecnologia dei Rollup ZK, chiamata ZKSwap, un servizio di pagamento chiamato ZKSquare e un mercato di NFT, chiamato ZKSea.", + "aztec-description": "Aztec Network è il primo Rollup ZK privato su Ethereum, che consente alle applicazioni decentralizzate di accedere a privacy e ridimensionamento.", "layer-2-note": "Nota:", "layer-2-ecosystem-portal": "Portale dell'Ecosistema", "layer-2-token-lists": "Elenchi di Token", diff --git a/src/intl/it/page-learn.json b/src/intl/it/page-learn.json new file mode 100644 index 00000000000..53a25baffb8 --- /dev/null +++ b/src/intl/it/page-learn.json @@ -0,0 +1,139 @@ +{ + "toc-learn-hub": "Learn Hub", + "toc-what-is-crypto-ethereum": "Cosa sono le criptovalute ed Ethereum?", + "toc-how-do-i-use-ethereum": "Come posso utilizzare Ethereum?", + "toc-what-is-ethereum-used-for": "Per cosa è utilizzato Ethereum?", + "toc-strengthen-the-ethereum-network": "Rafforzare la rete di Ethereum", + "toc-learn-about-the-ethereum-protocol": "Impara sul protocollo di Ethereum", + "toc-learn-about-the-ethereum-community": "Impara sulla community di Ethereum", + "toc-books-and-podcasts": "Libri e podcast", + "hero-header": "Informazioni su Ethereum", + "hero-subtitle": "La tua guida educativa al mondo di Ethereum. Scopri come funziona e come connetterti. Questa pagina include articoli, guide e risorse tecnici e non tecnici.", + "hero-button-lets-get-started": "Iniziamo", + "what-is-crypto-1": "Potresti aver sentito parlare di criptovalute, Bitcoin e blockchain. Questa pagina ti aiuterà ad apprendere come sono legate a Ethereum.", + "what-is-crypto-link-1": "E, in ogni caso, cos'è Ethereum?", + "what-is-crypto-2": "Bitcoin consente a chiunque di trasferire denaro globalmente. Anche Ethereum lo fa e consente a chiunque di creare e concordare qualsiasi tipo di contratto che possa immaginare. È sia resiliente che flessibile: qualsiasi programma informatico può essere eseguito su Ethereum.", + "what-is-ethereum-card-title": "Cos'è Ethereum?", + "what-is-ethereum-card-description": "Se sei nuovo, inizia qui ad apprendere perché Ethereum è importante.", + "what-is-ethereum-card-image-alt": "Illustrazione di una persona che sbircia in un bazar, che rappresenta Ethereum.", + "what-is-eth-card-title": "Cos'è ETH?", + "what-is-eth-description": "Ether (ETH) è la valuta alla base della rete e delle app di Ethereum.", + "where-can-i-get-eth-card-title": "Dove posso ottenere degli ETH?", + "where-can-i-get-eth-card-description": "Esistono molti modi per ottenere ETH, a seconda della tua posizione.", + "additional-reading-more-on-ethereum-basics": "Ulteriori informazioni sui fondamenti di Ethereum", + "additional-reading-what-are-smart-contracts": "Cosa sono i contratti intelligenti?", + "additional-reading-a-developers-intro": "Un'introduzione a Ethereum per gli sviluppatori", + "additional-reading-what-is-web3": "Cos'è web3?", + "additional-reading-value": "Cos'è il valore?", + "additional-reading-decentralize-everything": "Decentralizza tutto", + "how-do-i-use-ethereum-1": "Utilizzare Ethereum è come trasferirsi in un posto nuovo. Inizialmente sembrerà poco familiare, e ognuno si trasferisce per i propri motivi. Nonostante ciò, la prima cosa di cui avrai bisogno sono le nuove chiavi. Il software che crea e detiene le chiavi per la tua nuova casa è chiamato \"portafoglio\".", + "what-is-a-wallet-card-title": "Cos'è un portafoglio?", + "what-is-a-wallet-card-description": "I portafogli sono come portachiavi: memorizzano ciò che ti serve per ottenere l'accesso ai luoghi a cui tieni.", + "what-is-a-wallet-card-alt": "Figura di un robot.", + "find-a-wallet-card-title": "Trova un portafoglio", + "find-a-wallet-card-description": "Ti aiuteremo a trovare il portafoglio migliore a seconda delle caratteristiche che più ti importano.", + "find-a-wallet-button": "Elenco di portafogli", + "crypto-security-basics-card-title": "Fondamenti di sicurezza", + "crypto-security-basics-card-description": "Scopri come identificare le truffe e come evitare i trucchi più comuni.", + "crypto-security-basics-card-button": "Mantieni la sicurezza", + "things-to-consider-banner-title": "Cose da considerare utilizzando Ethereum", + "things-to-consider-banner-1": "Ogni transazione di Ethereum richiede una commissione nella forma di ETH, anchse se devi spostare token differenti basati su Ethereum, come gli stablecoin USDC o DAI.", + "things-to-consider-banner-2": "Le commissioni possono essere elevate a seconda del numero di persone che sta provando a utilizzare Ethereum, quindi consigliamo di utilizzare i", + "things-to-consider-banner-layer-2": "Livelli 2", + "additional-reading-more-on-using-ethereum": "Ulteriori informazioni sull'utilizzo di Ethereum", + "additional-reading-how-to-register-an-ethereum-account": "Come \"registrare\" un conto di Ethereum", + "additional-reading-how-to-use-a-wallet": "Come utilizzare un portafoglio", + "additional-reading-support-for-ethereum-and-wallets": "Supporto per Ethereum e i portafogli", + "additional-reading-layer-2": "Livello 2: ridurre le commissioni di transazione", + "what-is-ethereum-used-for-1": "Ethereum ha portato alla creazione di nuovi prodotti e servizi capaci di migliorare diverse aree delle nostre vite. Siamo ancora agli inizi, ma c'è molto di cui essere entusiasti.", + "defi-card-title": "Finanza Decentralizzata (DeFi)", + "defi-card-description": "Esplora un sistema finanziario alternativo, costruito senza banche e aperto a tutti.", + "defi-card-button": "Cos'è la DeFi?", + "stablecoins-card-title": "Stablecoin", + "stablecoins-card-description": "Le criptovalute sono ancorate al valore di una valuta, una materia prima o qualche altro strumento finanziario.", + "stablecoins-card-button": "Cosa sono le stablecoin?", + "nft-card-title": "Token non fungibili (NFT)", + "nft-card-description": "Rappresentano la proprietà di oggetti unici, dall'arte a titoli di proprietà fino a biglietti di concerti.", + "nft-card-button": "Cosa sono i NFT?", + "dao-card-title": "Organizzazioni autonome decentralizzate (DAO)", + "dao-card-description": "Consentono nuovi metodi per coordinare il lavoro senza un capo.", + "dao-card-button": "Cosa sono le DAO?", + "dapp-card-title": "Applicazioni decentralizzate (dapps)", + "dapp-card-description": "Creano un'economia digitale di servizi peer-to-peer.", + "dapp-card-button": "Esplora le dapp", + "emerging-use-cases-title": "Casi d'uso emergenti", + "emerging-use-cases-description": "Inoltre, esistono altre industrie di spicco create o migliorate con Ethereum:", + "play-to-earn": "Giochi play-to-earn (P2E)", + "fundraising-through-quadratic-funding": "Raccolte fondi tramite finanziamenti quadratici", + "supply-chain-management": "Gestione della filiera", + "more-on-ethereum-use-cases": "Maggiori informazioni sui casi d'uso di Ethereum", + "more-on-ethereum-use-cases-link": "La blockchain nei paesi in via di sviluppo", + "strengthening-the-ethereum-network-description": "Puoi aiutare a proteggere Ethereum e allo stesso tempo ottenere ricompense mettendo i tuoi ETH in staking. Esistono diverse opzioni per lo staking, a seconda della tua conoscenza tecnica e di quanti ETH possiedi.", + "staking-ethereum-card-title": "Staking su Ethereum", + "staking-ethereum-card-description": "Scopri come iniziare a mettere in staking i tuoi ETH.", + "staking-ethereum-card-button": "Inizia a fare staking", + "run-a-node-card-title": "Gestire un nodo", + "run-a-node-card-description": "Rivesti un ruolo cruciale nella rete di Ethereum eseguendo un nodo.", + "learn-about-ethereum-protocol-description": "Per gli utenti più interessati alla parte tecnica della rete di Ethereum.", + "energy-consumption-card-title": "Consumo energetico", + "energy-consumption-card-description": "Quanta energia è consumata da Ethereum?", + "energy-consumption-card-button": "Ethereum è green?", + "ethereum-upgrades-card-title": "Roadmap di Ethereum", + "ethereum-upgrades-card-description": "La tabella di marcia di Ethereum la rende più scalabile, sicura e sostenibile.", + "ethereum-upgrades-card-button": "Esplora la roadmap", + "ethereum-whitepaper-card-title": "Whitepaper di Ethereum", + "ethereum-whitepaper-card-description": "La proposta originale di Ethereum scritta da Vitalik Buterin nel 2014.", + "ethereum-whitepaper-card-button": "Leggi il whitepaper", + "more-on-ethereum-protocol-title": "Maggiori informazioni sul protocollo di Ethereum", + "more-on-ethereum-protocol-ethereum-for-developers": "Ethereum per sviluppatori", + "more-on-ethereum-protocol-eips": "Proposte di miglioramento di Ethereum (EIP)", + "more-on-ethereum-protocol-history": "Storia di Ethereum", + "more-on-ethereum-protocol-governance": "Governance", + "more-on-ethereum-protocol-bridges": "Bridge", + "more-on-ethereum-protocol-kernel": "Kernel", + "more-on-ethereum-protocol-week-in-ethereum": "Settimana in Ethereum News", + "ethereum-community-description": "Il successo di Ethereum è dovuto alla sua community incredibilmente dedicata. Migliaia di persone motivanti e motivate aiutano a far avanzare la visione di Ethereum. Vieni a unirti a noi!", + "community-hub-card-title": "Hub della community", + "community-hub-card-description": "La nostra community include persone da tutte le provenienze sociali.", + "community-hub-card-alt": "Illustrazione di un gruppo di costruttori che lavorano insieme.", + "community-hub-card-button": "Esplora di più", + "get-involved-card-title": "Come posso partecipare?", + "get-involved-card-description": "Tu (sì, tu!) sei il benvenuto a contribuire alla community di Ethereum.", + "online-communities-card-title": "Community online", + "online-communities-card-description": "Le community online forniscono un'ottima opportunità per porre domande più specifiche o essere coinvolti.", + "online-communities-card-button": "Esplora le community", + "books-about-ethereum": "Libri su Ethereum e le criptovalute", + "proof-of-stake-title": "Proof of Stake", + "proof-of-stake-description": "13 settembre 2022 - Vitalik Buterin, Nathan Schneider", + "cryptopians-title": "The Cryptopians", + "cryptopians-description": "22 febbraio 2022 - Laura Shin", + "out-of-the-ether-title": "Out of the Ether", + "out-of-the-ether-description": "29 settembre 2020 - Matthew Leising", + "the-infinite-machine-title": "The Infinite Machine", + "the-infinite-machine-description": "14 luglio 2020 - Camila Russo", + "the-age-of-cryptocurrency-title": "The Age of Cryptocurrency", + "the-age-of-cryptocurrency-description": "12 gennaio 2016 - Paul Vigna, Michael J. Casey", + "the-truth-machine-title": "The Truth Machine", + "the-truth-machine-description": "27 febbraio 2018 - Paul Vigna, Michael J. Casey", + "digital-gold-title": "Digital Gold", + "digital-gold-description": "24 maggio 2021 - Nathaniel Popper", + "kings-of-crypto-title": "Kings of Crypto", + "kings-of-crypto-description": "15 dicembre 2020 - Jeff John Roberts", + "mastering-ethereum-title": "Mastering Ethereum", + "mastering-ethereum-description": "23 dicembre 2018 - Andreas M. Antonopoulos, Gavin Wood Ph.D.", + "podcasts-about-ethereum": "Podcast su Ethereum e le criptovalute", + "bankless-title": "Bankless", + "bankless-description": "Una guida alla cripto finanza", + "uncommon-core-title": "Uncommon Core", + "uncommon-core-description": "Esplora la natura trasformativa della valuta a fiducia minimizzata e dei servizi finanziari", + "zeroknowledge-title": "Zero Knowledge", + "zeroknowledge-description": "Approfondisci la tecnologia che supporterà il web decentralizzato emergente e la community che lo sta costruendo", + "epicenter-title": "Epicenter", + "epicenter-description": "Esplora le implicazioni tecniche, economiche e sociali dell'industria delle Cripto", + "unchained-title": "Unchained", + "unchained-description": "Offre approfondimenti sulle persone che stanno creando l'Internet decentralizzato, i dettagli di tale tecnologia che potrebbero sostenere il nostro futuro e alcuni degli argomenti più spinosi sulle cripto, come regolamenti, sicurezza e privacy", + "into-the-bytecode-title": "Into the Bytecode", + "into-the-bytecode-description": "Un podcast sulle idee alla base delle cripto", + "the-daily-gwei-title": "The Daily Gwei", + "the-daily-gwei-description": "Riepiloghi, aggiornamenti e analisi delle notizie di Ethereum" +} diff --git a/src/intl/it/page-run-a-node.json b/src/intl/it/page-run-a-node.json index 10784c8ebb6..6f29f513117 100644 --- a/src/intl/it/page-run-a-node.json +++ b/src/intl/it/page-run-a-node.json @@ -1,72 +1,72 @@ { - "page-run-a-node-build-your-own-title": "Costruisci il tuo", - "page-run-a-node-build-your-own-hardware-title": "Passo 1 – Hardware", + "page-run-a-node-build-your-own-title": "Creane uno personale", + "page-run-a-node-build-your-own-hardware-title": "Passaggio 1: Hardware", "page-run-a-node-build-your-own-minimum-specs": "Specifiche minime", - "page-run-a-node-build-your-own-min-ram": "4 - 8 GB RAM", - "page-run-a-node-build-your-own-ram-note-1": "Vedi nota sullo staking", - "page-run-a-node-build-your-own-ram-note-2": "Vedi nota su Raspberry Pi", - "page-run-a-node-build-your-own-min-ssd": "SSD 2 TB", - "page-run-a-node-build-your-own-ssd-note": "SSD necessario per le velocità di scrittura richieste.", + "page-run-a-node-build-your-own-min-ram": "Da 4 a 8 GB di RAM", + "page-run-a-node-build-your-own-ram-note-1": "Consulta le note sullo staking", + "page-run-a-node-build-your-own-ram-note-2": "Consulta le note su Raspberry Pi", + "page-run-a-node-build-your-own-min-ssd": "2 TB di SSD", + "page-run-a-node-build-your-own-ssd-note": "I SSD sono necessari per le velocità di scrittura richieste.", "page-run-a-node-build-your-own-recommended": "Raccomandato", "page-run-a-node-build-your-own-nuc": "Intel NUC, 7ª generazione o superiore", "page-run-a-node-build-your-own-nuc-small": "Processore x86", - "page-run-a-node-build-your-own-connection": "Connessione internet via cavo", - "page-run-a-node-build-your-own-connection-small": "Non necessaria, ma fornisce una configurazione più semplice e una connessione più stabile", + "page-run-a-node-build-your-own-connection": "Connessione a Internet cablata", + "page-run-a-node-build-your-own-connection-small": "Non obbligatoria, ma fornisce una più semplice configurazione e una connessione più stabile", "page-run-a-node-build-your-own-peripherals": "Monitor e tastiera", - "page-run-a-node-build-your-own-peripherals-small": "A meno che tu non stia usando DAppNode o una configurazione ssh/headless", - "page-run-a-node-build-your-own-software": "Passo 2 – Software", - "page-run-a-node-build-your-own-software-option-1-title": "Opzione 1 – DAppNode", - "page-run-a-node-build-your-own-software-option-1-description": "Quando sei pronto col tuo hardware, il sistema operativo DAppNode è scaricabile usando qualsiasi computer ed è installabile su un nuovo SSD tramite unità USB.", + "page-run-a-node-build-your-own-peripherals-small": "A meno che tu non stia utilizzando DAppNode, o una configurazione ssh/headless", + "page-run-a-node-build-your-own-software": "Passaggio 2: Software", + "page-run-a-node-build-your-own-software-option-1-title": "Opzione 1: DAppNode", + "page-run-a-node-build-your-own-software-option-1-description": "Quando il tuo hardware è pronto, il sistema operativo DAppNode è scaricabile utilizzando qualsiasi computer, nonché installabile su un nuovo SSD, tramite chiavetta USB.", "page-run-a-node-build-your-own-software-option-1-button": "Configurazione di DAppNode", "page-run-a-node-build-your-own-software-option-2-title": "Opzione 2 – Riga di comando", - "page-run-a-node-build-your-own-software-option-2-description-1": "Per il massimo controllo, gli utenti esperti potrebbero preferire l'uso della linea di comando.", - "page-run-a-node-build-your-own-software-option-2-description-2": "Visualizza le nostre documentazioni per sviluppatori per ulteriori informazioni sui primi passi per la selezione del client.", + "page-run-a-node-build-your-own-software-option-2-description-1": "Per il massimo controllo, gli utenti esperti potrebbero preferire l'utilizzo della riga di comando.", + "page-run-a-node-build-your-own-software-option-2-description-2": "Consulta le nostre documentazioni per sviluppatori per ulteriori informazioni sui primi passi per la selezione del client.", "page-run-a-node-build-your-own-software-option-2-button": "Configurazione della riga di comando", "page-run-a-node-buy-fully-loaded-title": "Acquista una soluzione completa", - "page-run-a-node-buy-fully-loaded-description": "Ordina un'opzione pronta all'uso dai rivenditori per un'esperienza d'accesso più semplice.", + "page-run-a-node-buy-fully-loaded-description": "Ordina un'opzione pronta all'uso dai rivenditori, per un'esperienza d'accesso semplificata.", "page-run-a-node-buy-fully-loaded-note-1": "Non occorre programmare.", - "page-run-a-node-buy-fully-loaded-note-2": "Configurazione simile ad app con GUI.", + "page-run-a-node-buy-fully-loaded-note-2": "Configurazione simile ad app, con una GUI.", "page-run-a-node-buy-fully-loaded-note-3": "Nessuna riga di comando necessaria.", "page-run-a-node-censorship-resistance-title": "Resistenza alla censura", - "page-run-a-node-censorship-resistance-preview": "Assicurati l'accesso quando ne hai bisogno, senza censure.", - "page-run-a-node-censorship-resistance-1": "Un nodo di terze parti potrebbe scegliere di rifiutare le transazioni da indirizzi IP specifici o che coinvolgono conti specifici, impedendoti potenzialmente di usare la rete quando ti serve. ", - "page-run-a-node-censorship-resistance-2": "Avere il proprio nodo a cui inviare le transazioni ti garantisce di poter trasmettere la tua transazione al resto della rete in pari in qualsiasi momento.", + "page-run-a-node-censorship-resistance-preview": "Assicurati l'accesso quando necessario, senza censure.", + "page-run-a-node-censorship-resistance-1": "Un nodo di terze parti potrebbe scegliere di rifiutare le transazioni da indirizzi IP specifici, o che coinvolgono conti specifici, potenzialmente impedendoti di utilizzare la rete quando necessario. ", + "page-run-a-node-censorship-resistance-2": "Far inviare le transazioni al tuo nodo personale, ti garantisce di poter trasmettere la tua transazione al resto della rete tra pari, in qualsiasi momento.", "page-run-a-node-community-title": "Trova qualcuno che ti aiuti", - "page-run-a-node-community-description-1": "Le piattaforme online come Discord o Reddit, ospitano un gran numero di sviluppatori della community, desiderosi di aiutarti con qualsiasi domanda ti possa venire in mente.", - "page-run-a-node-community-description-2": "Non fare da solo. Se hai una domanda, è probabile che qualcuno qui possa aiutarti a trovare una risposta.", + "page-run-a-node-community-description-1": "Le piattaforme online come Discord o Reddit, ospitano un gran numero di sviluppatori della community, desiderosi di aiutarti con qualsiasi domanda che possa venirti in mente.", + "page-run-a-node-community-description-2": "Non fare da solo. Se hai una domanda, è probabile che, qui, qualcuno ti possa aiutare a trovare una risposta.", "page-run-a-node-community-link-1": "Unisciti al Discord di DAppNode", - "page-run-a-node-community-link-2": "Trova comunità online", + "page-run-a-node-community-link-2": "Trova delle community online", "page-run-a-node-choose-your-adventure-title": "Scegli la tua avventura", - "page-run-a-node-choose-your-adventure-1": "Avrai bisogno di dell'hardware per iniziare. Sebbene eseguire il software del nodo sia possibile su un computer personale, avere una macchina dedicata può largamente migliorare le prestazioni del tuo nodo, minimizzandone l'impatto sul tuo computer.", - "page-run-a-node-choose-your-adventure-2": "Selezionando l'hardware, considera che la catena è in continua espansione e che la manutenzione sarà inevitabilmente necessaria. Le specifiche superiori possono aiutare a ritardare l'esigenza di manutenzione del nodo.", - "page-run-a-node-choose-your-adventure-build-1": "Un'opzione più economica e personalizzabile per gli utenti leggermente più tecnici.", - "page-run-a-node-choose-your-adventure-build-bullet-1": "Procurati autonomamente i componenti.", + "page-run-a-node-choose-your-adventure-1": "Avrai bisogno del hardware, per iniziare. Sebbene l'operazione del software del nodo sia possibile su un computer personale, avere una macchina dedicata può migliorare ampiamente le prestazioni del tuo nodo, minimizzandone l'impatto sul tuo dispositivo principale.", + "page-run-a-node-choose-your-adventure-2": "Selezionando un hardware, considera che la catena è in continua espansione, e che sarà inevitabilmente necessario un minimo di manutenzione. Le specifiche superiori possono aiutare a ritardare la necessità di manutenzione del nodo.", + "page-run-a-node-choose-your-adventure-build-1": "Un'opzione più economica e personalizzabile, per utenti lievemente più tecnici.", + "page-run-a-node-choose-your-adventure-build-bullet-1": "Procurati le tue parti.", "page-run-a-node-choose-your-adventure-build-bullet-2": "Installa DAppNode.", - "page-run-a-node-choose-your-adventure-build-bullet-3": "In alternativa, scegli il tuo sistema operativo e i tuoi client.", + "page-run-a-node-choose-your-adventure-build-bullet-3": "Altrimenti, scegli il tuo OS e i tuoi client.", "page-run-a-node-choose-your-adventure-build-start": "Inizia a sviluppare", "page-run-a-node-decentralized-title": "Decentralizzazione", - "page-run-a-node-decentralized-preview": "Resistere al rafforzamento dei punti di fallimento centralizzati.", - "page-run-a-node-decentralized-1": "I server su cloud centralizzati possono fornire molta potenza di calcolo, ma costituiscono un obiettivo per gli stati e le nazioni, o per gli utenti malevoli, intenzionati a perturbare la rete.", - "page-run-a-node-decentralized-2": "La resilienza della rete è ottenuta con più nodi, in posizioni geograficamente diverse, operati da più persone di diversa estrazione sociale. Più persone eseguono il proprio nodo, minore sarà la dipendenza dai punti centralizzati di guasto, rendendo la rete più forte.", + "page-run-a-node-decentralized-preview": "Resisti al rafforzamento dei punti centralizzati di guasto.", + "page-run-a-node-decentralized-1": "I server centralizzati su cloud possono fornire molta potenza di calcolo, ma costituiscono un bersaglio per gli stati o gli utenti malevoli, intenzionati a compromettere la rete.", + "page-run-a-node-decentralized-2": "La resilienza della rete è ottenuta con più nodi, in posizioni geograficamente diverse, operati da più persone, da diversi contesti. All'aumentare delle persone che operano un proprio nodo, si riduce la dipendenza dai punti di guasto centralizzati, rafforzando la rete.", "page-run-a-node-further-reading-title": "Ulteriori letture", - "page-run-a-node-further-reading-1-link": "Padroneggiare Ethereum - Dovrei eseguire un nodo completo?", + "page-run-a-node-further-reading-1-link": "Padroneggiare Ethereum: Dovrei operare un Nodo Completo?", "page-run-a-node-further-reading-1-author": "Andreas Antonopoulos", - "page-run-a-node-further-reading-2-link": "Ethereum su ARM - Guida Iniziale Rapida", + "page-run-a-node-further-reading-2-link": "Ethereum su ARM: Guida Iniziale Rapida", "page-run-a-node-further-reading-3-link": "I limiti della scalabilità della blockchain", "page-run-a-node-further-reading-3-author": "Vitalik Buterin", "page-run-a-node-getting-started-title": "Primi passi", - "page-run-a-node-getting-started-software-section-1": "Agli albori della rete, gli utenti necessitavano di esser capaci di interfacciarsi con la riga di comando, per poter gestire un nodo di Ethereum.", - "page-run-a-node-getting-started-software-section-1-alert": "Se questa è la tua preferenza e hai le competenze per farlo, sentiti libero di dare un'occhiata alla nostra documentazione tecnica.", + "page-run-a-node-getting-started-software-section-1": "Agli albori della rete, gli utenti necessitavano di potersi interfacciare con la riga di comando, per poter operare un nodo di Ethereum.", + "page-run-a-node-getting-started-software-section-1-alert": "Se questa è la tua preferenza e hai le competenze per farlo, sentiti libero di consultare le nostre documentazioni tecniche.", "page-run-a-node-getting-started-software-section-1-link": "Avvia un nodo di Ethereum", - "page-run-a-node-getting-started-software-section-2": "Ora, abbiamo DAppNode, che è un software libero e open source che dà agli utenti un'esperienza simile a quella di un'app, gestendo il loro nodo.", - "page-run-a-node-getting-started-software-section-3a": "In pochi semplici tocchi, puoi mettere in funzione il tuo nodo.", - "page-run-a-node-getting-started-software-section-3b": "DAppNode semplifica l'esecuzione di nodi completi per gli utenti, nonché delle dapp e di altre reti P2P, senza dover toccare la riga di comando. Questo semplifica la partecipazione di tutti e crea una rete più decentralizzata.", + "page-run-a-node-getting-started-software-section-2": "Ora, abbiamo DAppNode, un software libero e open source che fornisce agli utenti un'esperienza simile a quella di un'app, per la gestione del proprio nodo.", + "page-run-a-node-getting-started-software-section-3a": "In pochi tocchi, puoi mettere in funzione il tuo nodo.", + "page-run-a-node-getting-started-software-section-3b": "DAppNode semplifica l'operazione dei nodi completi, nonché di dapp e altre reti P2P, per gli utenti, senza dover toccare la riga di comando. Questo semplifica la partecipazione per tutti, creando una rete più decentralizzata.", "page-run-a-node-getting-started-software-title": "Parte 2: Software", "page-run-a-node-glyph-alt-terminal": "Glifo del terminale", "page-run-a-node-glyph-alt-phone": "Glifo del tocco sul telefono", "page-run-a-node-glyph-alt-dappnode": "Glifo di DAppNode", "page-run-a-node-glyph-alt-pnp": "Glifo del plug-n-play", - "page-run-a-node-glyph-alt-hardware": "Glifo dell'hardware", + "page-run-a-node-glyph-alt-hardware": "Glifo del hardware", "page-run-a-node-glyph-alt-software": "Glifo del download del software", "page-run-a-node-glyph-alt-privacy": "Glifo della privacy", "page-run-a-node-glyph-alt-censorship-resistance": "Glifo del megafono per la resistenza alla censura", @@ -76,60 +76,60 @@ "page-run-a-node-glyph-alt-sovereignty": "Glifo della sovranità", "page-run-a-node-hero-alt": "Grafico del nodo", "page-run-a-node-hero-header": "Assumi il pieno controllo.
Esegui il tuo nodo.", - "page-run-a-node-hero-subtitle": "Diventa completamente sovrano, aiutando a proteggere la rete. Diventa Ethereum.", + "page-run-a-node-hero-subtitle": "Diventa completamente sovrano, aiutando a proteggere la rete. Diventa parte di Ethereum.", "page-run-a-node-hero-cta-1": "Scopri di più", - "page-run-a-node-hero-cta-2": "Iniziamo!", + "page-run-a-node-hero-cta-2": "Approfondiamo!", "page-run-a-node-install-manually-title": "Installa manualmente", - "page-run-a-node-install-manually-1": "Se sei un utente più tecnico e hai deciso di costruire il tuo dispositivo, DAppNode è scaricabile da qualsiasi computer e installabile su un nuovo SSD tramite un'unità USB.", - "page-run-a-node-meta-description": "Un'introduzione a cosa, perché e come eseguire un nodo di Ethereum.", + "page-run-a-node-install-manually-1": "Se sei un utente più tecnico e hai deciso di costruire il tuo dispositivo, DAppNode può essere scaricato da qualsiasi computer e installato su un nuovo SSD, tramite una chiavetta USB.", + "page-run-a-node-meta-description": "Un'introduzione su cosa, perché e come eseguire un nodo di Ethereum.", "page-run-a-node-participate-title": "Partecipa", - "page-run-a-node-participate-preview": "La rivoluzione della decentralizzazione inizia con te.", - "page-run-a-node-participate-1": "Eseguendo un nodo, diventi parte di un movimento globale per decentralizzare il controllo e il potere sul mondo dell'informazione.", - "page-run-a-node-participate-2": "Se sei un possessore, porta valore ai tuoi ETH supportando la salute e la decentralizzazione della rete e assicurati di avere voce in capitolo nel suo futuro.", - "page-run-a-node-privacy-title": "Privacy e sicurezza", - "page-run-a-node-privacy-preview": "Smettila di far trapelare le tue informazioni personali a nodi di terze parti.", - "page-run-a-node-privacy-1": "Quando si inviano transazioni utilizzando i nodi pubblici, i dati personali possono trapelare a questi servizi di terze parti, ad esempio il tuo indirizzo IP o gli indirizzi Ethereum che possiedi.", - "page-run-a-node-privacy-2": "Puntando i portafogli compatibili al tuo nodo, puoi usare il tuo portafoglio per interagire privatamente e in sicurezza con la blockchain.", - "page-run-a-node-privacy-3": "Inoltre, se un nodo malevolo distribuisce una transazione non valida, il tuo nodo si limiterà a ignorarla. Ogni transazione è verificata localmente sulla tua macchina, quindi, non devi affidarti a nessuno.", + "page-run-a-node-participate-preview": "La rivoluzione della decentralizzazione parte da te.", + "page-run-a-node-participate-1": "Operando un nodo, diventi parte di un movimento globale per decentralizzare il controllo e il potere su un mondo di informazioni.", + "page-run-a-node-participate-2": "Se ne possiedi, porta valore ai tuoi ETH supportando la salute e la decentralizzazione della rete, e assicurati di avere voce in capitolo nel suo futuro.", + "page-run-a-node-privacy-title": "Privacy e Sicurezza", + "page-run-a-node-privacy-preview": "Dì basta alla trapelazione delle tue informazioni personali, ai nodi di terze parti.", + "page-run-a-node-privacy-1": "Inviando le transazioni utilizzando i nodi pubblici, le informazioni personali, come il tuo indirizzo IP e quali indirizzi di Ethereum possiedi, possono trapelare a tali servizi di terze parti.", + "page-run-a-node-privacy-2": "Puntando dei portafogli compatibili al proprio nodo, puoi utilizzarli per interagire privatamente e in sicurezza con la blockchain.", + "page-run-a-node-privacy-3": "Inoltre, se un nodo malevolo distribuisce una transazione non valida, il tuo nodo si limiterà a ignorarla. Ogni transazione è verificata localmente sulla tua macchina, così che non debba affidarti a nessuno.", "page-run-a-node-rasp-pi-title": "Una nota su Raspberry Pi (processore ARM)", - "page-run-a-node-rasp-pi-description": "I Raspberry Pi sono computer leggeri ed economici, ma hanno delle limitazioni che possono avere un impatto sulle prestazioni del tuo nodo. Anche se attualmente non sono raccomandati per lo staking, possono essere un'opzione eccellente ed economica per eseguire un nodo per uso personale, con soli 4-8 GB di RAM.", + "page-run-a-node-rasp-pi-description": "I Raspberry Pi sono computer leggeri ed economici, aventi delle limitazioni che potrebbero influenzare le prestazioni del tuo nodo. Sebbene non siano al momento consigliati peer lo staking, possono rappresentare un'opzione eccellente ed economica per operare un nodo per uso personale, con meno di 4 e fino a 8 GB di RAM.", "page-run-a-node-rasp-pi-note-1-link": "DAppNode su ARM", - "page-run-a-node-rasp-pi-note-1-description": "Visualizza queste istruzioni se pianifichi di eseguire DAppNode su un Raspberry Pi", - "page-run-a-node-rasp-pi-note-2-link": "Ethereum sulla documentazione di ARM", - "page-run-a-node-rasp-pi-note-2-description": "Scopri come configurare un nodo tramite la riga di comando su un Raspberry Pi", + "page-run-a-node-rasp-pi-note-1-description": "Consulta queste istruzioni se vorresti eseguire DAppNode su un Raspberry Pi", + "page-run-a-node-rasp-pi-note-2-link": "Documentazione di Ethereum su ARM", + "page-run-a-node-rasp-pi-note-2-description": "Impara a configurare un nodo tramite la riga di comando, su un Raspberry Pi", "page-run-a-node-rasp-pi-note-3-link": "Esegui un nodo con Raspberry Pi", - "page-run-a-node-rasp-pi-note-3-description": "Resta qui se preferisci i tutorial", - "page-run-a-node-shop": "Acquista", - "page-run-a-node-shop-avado": "Acquista Avado", - "page-run-a-node-shop-dappnode": "Acquista DAppNode", + "page-run-a-node-rasp-pi-note-3-description": "Se preferisci i tutorial, resta qui", + "page-run-a-node-shop": "Negozio", + "page-run-a-node-shop-avado": "Acquista su Avado", + "page-run-a-node-shop-dappnode": "Acquista su DAppNode", "page-run-a-node-staking-title": "Fai staking con i tuoi ETH", - "page-run-a-node-staking-description": "Benché non sia obbligatorio, con un nodo attivo e operativo sei un passo più vicino a fare staking con i tuoi ETH per guadagnare ricompense e contribuire a un componente diverso della sicurezza di Ethereum.", + "page-run-a-node-staking-description": "Sebbene non sia obbligatorio, con un nodo attivo, sei a un passo dal mettere i tuoi ETH in staking, per guadagnare ricompense e aiutare a contribuire a un componente differente della sicurezza di Ethereum.", "page-run-a-node-staking-link": "Fa staking di ETH", "page-run-a-node-staking-plans-title": "Stai pensando di fare staking?", - "page-run-a-node-staking-plans-description": "Per massimizzare l'efficienza del tuo validatore, è consigliato un minimo di 16 GB di RAM, ma 32 GB sarebbero meglio, con un punteggio dell'indice di riferimento della CPU di 6667+ su cpubenchmark.net. È anche consigliato che gli staker abbiano accesso a una larghezza di banda di Internet ad alta velocità, sebbene non sia un requisito assoluto.", - "page-run-a-node-staking-plans-ethstaker-link-label": "Come acquistare l'hardware per un validatore Ethereum", - "page-run-a-node-staking-plans-ethstaker-link-description": "EthStaker entra più in dettaglio in questo speciale di un'ora", + "page-run-a-node-staking-plans-description": "Per massimizzare l'efficienza del tuo validatore, è consigliato un minimo di 16 GB di RAM, ma 32 GB sarebbero meglio, con un punteggio dell'indice di riferimento della CPU di 6667+ su cpubenchmark.net. Inoltre, si consiglia che gli staker abbiano accesso a larghezza di banda ad alta velocità illimitata, sebbene non si tratti di un requisito assoluto.", + "page-run-a-node-staking-plans-ethstaker-link-label": "Come acquistare hardware per un validatore di Ethereum", + "page-run-a-node-staking-plans-ethstaker-link-description": "EthStaker approfondisce l'argomento, in questo speciale di un'ora", "page-run-a-node-sovereignty-title": "Sovranità", - "page-run-a-node-sovereignty-preview": "Pensa di eseguire un nodo come il passo successivo all'ottenimento del tuo portafoglio Ethereum.", - "page-run-a-node-sovereignty-1": "Un portafoglio Ethereum ti permette di assumere la piena custodia e il controllo dei tuoi attivi digitali detenendo le chiavi private dei tuoi indirizzi. Queste chiavi però non ti dicono lo stato attuale della blockchain, come il saldo del tuo portafoglio.", - "page-run-a-node-sovereignty-2": "Come impostazione predefinita, i portafogli Ethereum di solito raggiungono un nodo di terze parti, come Infura o Alchemy, per la consultazione dei tuoi saldi. Eseguire il proprio nodo autonomamente permette di avere la propria copia della blockchain di Ethereum.", + "page-run-a-node-sovereignty-preview": "Pensa all'esecuzione di un nodo come il passaggio successivo all'ottenimento del tuo portafoglio di Ethereum.", + "page-run-a-node-sovereignty-1": "Un portafoglio di Ethereum ti consente di assumere la piena custodia e controllo delle tue risorse digitali, detenendo le chiavi private dei tuoi indirizzi. Queste, però, non ti comunicheranno lo stato corrente della blockchain, così come il saldo del tuo portafoglio.", + "page-run-a-node-sovereignty-2": "Per loro natura, i portafogli di Ethereum contattano tipicamente un nodo di terze parti, come Infura o Alchemy, cercando i tuoi saldi. Operare il proprio nodo consente di possedere una propria copia della blockchain di Ethereum.", "page-run-a-node-title": "Esegui un nodo", "page-run-a-node-voice-your-choice-title": "Dai voce alla tua scelta", - "page-run-a-node-voice-your-choice-preview": "Non rinunciare al controllo in caso di fork.", - "page-run-a-node-voice-your-choice-1": "In caso di fork della catena, ovvero qualora emergessero due catene con due serie di regole diverse, l'esecuzione del proprio nodo garantisce la possibilità di scegliere quale set di regole supportare. Sta a te decidere se adeguarti o meno alle nuove regole e se supportare o meno i cambiamenti proposti.", - "page-run-a-node-voice-your-choice-2": "Se stai facendo staking con gli ETH, l'esecuzione del tuo nodo ti consente di scegliere il tuo client, minimizzare il rischio di slashing e reagire alle richieste fluttuanti della rete nel tempo. Lo staking con una terza parte fa perdere il tuo voto su quale client ritieni sia la scelta migliore.", + "page-run-a-node-voice-your-choice-preview": "Non rinunciare al controllo in caso di una biforcazione.", + "page-run-a-node-voice-your-choice-1": "Nel caso di una biforcazione della catena, in cui due catene emergono con due serie differenti di regole, operare il proprio nodo garantisce l'abilità di scegliere quali serie di regole supportare. Il passaggio alle nuove regole e il supporto delle modifiche proposte, dipende da te.", + "page-run-a-node-voice-your-choice-2": "Se stai mettendo degli ETH in staking, operare il proprio nodo ti consente di scegliere il tuo client, minimizzando il rischio di taglio e reagendo alla domanda fluttuante della rete, nel tempo. Lo staking con una terza parte, fa rinunciare alla possibilità di votare quale client credi che sia la scelta migliore.", "page-run-a-node-what-title": "Cosa significa \"eseguire un nodo\"?", "page-run-a-node-what-1-subtitle": "Eseguire il software.", - "page-run-a-node-what-1-text": "Conosciuto come \"client\", questo software scarica una copia della blockchain di Ethereum e verifica la validità di ogni blocco, quindi la mantiene aggiornata con nuovi blocchi e transazioni e aiuta gli altri a scaricare e aggiornare le proprie copie.", - "page-run-a-node-what-2-subtitle": "Con l'hardware.", - "page-run-a-node-what-2-text": "Ethereum è progettato per eseguire un nodo su computer di media qualità. È possibile utilizzare qualsiasi personal computer, ma la maggior parte degli utenti sceglie di eseguire il proprio nodo su hardware dedicato per eliminare l'impatto sulle prestazioni della propria macchina e ridurre al minimo i tempi di inattività del nodo.", - "page-run-a-node-what-3-subtitle": "Mentre si è online.", - "page-run-a-node-what-3-text": "Eseguire un nodo Ethereum può sembrare complicato all'inizio, ma è semplicemente l'atto di eseguire continuamente il software client su un computer mentre è connesso a Internet. Mentre è offline, il tuo nodo sarà semplicemente inattivo fino a quando non tornerà online e si metterà al passo con le ultime modifiche.", + "page-run-a-node-what-1-text": "Noto come \"client\", questo software scarica una copia della blockchain di Ethereum, verificando la valdiità di ogni blocco e mantenendola aggiornata con nuovi blocchi e transazioni, nonché aiutando gli altri a scaricare e caricare le proprie copie.", + "page-run-a-node-what-2-subtitle": "Con hardware.", + "page-run-a-node-what-2-text": "Ethereum è progettato per eseguire un nodo su computer di media qualità. Puoi utilizzare qualsiasi computer personale, ma gran parte degli utenti sceglie di eseguire il proprio nodo su hardware dedicato, per eliminare l'impatto sulle prestazioni della propria macchina, nonché per minimizzare l'inattività del nodo.", + "page-run-a-node-what-3-subtitle": "Mentre è online.", + "page-run-a-node-what-3-text": "Eseguire un nodo di Ethereum potrebbe inizialmente sembrare complicato, ma è semplicemente l'atto di eseguire continuamente il software del client, su un computer connesso a Internet. Mentre è offline, il tuo nodo sarà semplicemente inattivo, fino al suo ritorno online, quando si metterà al passo con le modifiche più recenti.", "page-run-a-node-who-title": "Chi dovrebbe eseguire un nodo?", - "page-run-a-node-who-preview": "Tutti! I nodi non sono solo per i validatori di Proof of Stake. Chiunque può eseguire un nodo—non occorre nemmeno disporre di ETH.", - "page-run-a-node-who-copy-1": "Non è necessario che tu metta ETH in staking per operare un nodo. Difatti, ogni altro nodo su Ethereum considera responsabili i validatori.", - "page-run-a-node-who-copy-2": "Forse non otterrai le ricompense finanziarie guadagnate da validatori, ma l'esecuzione di un nodo offre agli utenti di Ethereum molti altri benefici utili, tra cui la privacy, la sicurezza, la minore dipendenza da server di terze parti, la resistenza alla censura nonché una migliore salute e decentralizzazione della rete.", - "page-run-a-node-who-copy-3": "Avere il proprio nodo significa che non occorre fare affidamento sulle informazioni sullo stato della rete fornite da una terza parte.", + "page-run-a-node-who-preview": "Chiunque! I nodi non sono soltanto destinati ai validatori del proof-of-stake. Chiunque può eseguire un nodo; non occorre nemmeno disporre di ETH.", + "page-run-a-node-who-copy-1": "Non necessiti di mettere ETH in staking per eseguire un nodo. Difatti, è ogni altro nodo su Ethereum, a considerare responsabili i validatori.", + "page-run-a-node-who-copy-2": "Forse non riceverai le ricompense finanziarie guadagnate dai validatori, ma esistono molti altri benefici da prendere in considerazione, derivati dall'esecuzione di un nodo, per qualsiasi utente di Ethereum, tra cui privacy, sicurezza, minore dipendenza da server di terze parti, resistenza alla censura e migliore salute e decentralizzazione della rete.", + "page-run-a-node-who-copy-3": "Possedere un proprio nodo significa che non occorre affidarsi alle informazioni sullo stato della rete, fornite da una terza parte.", "page-run-a-node-who-copy-bold": "Non fidarti. Verifica.", "page-run-a-node-why-title": "Perché eseguire un nodo?" } diff --git a/src/intl/it/page-stablecoins.json b/src/intl/it/page-stablecoins.json index a21b7cff9db..cc19b2df48b 100644 --- a/src/intl/it/page-stablecoins.json +++ b/src/intl/it/page-stablecoins.json @@ -1,166 +1,166 @@ { - "page-stablecoins-accordion-borrow-crypto-collateral": "Garanzia per le criptovalute", - "page-stablecoins-accordion-borrow-crypto-collateral-copy": "Con Ethereum puoi prendere in prestito direttamente da altri utenti senza scambiare i tuoi ETH. Questo può rappresentare un vantaggio: alcuni lo fanno per accumulare più ETH.", - "page-stablecoins-accordion-borrow-crypto-collateral-copy-p2": "Ma poiché il prezzo dell'ETH è instabile, serviranno garanzie extra. Significa che se vuoi prendere in prestito 100 stablecoin avrai probabilmente bisogno di almeno $150 in ETH. Questo sistema protegge il sistema e i prestatori.", - "page-stablecoins-accordion-borrow-crypto-collateral-link": "Maggiori informazioni su stablecoin supportati da criptovalute", + "page-stablecoins-accordion-borrow-crypto-collateral": "Garanzia per criptovalute", + "page-stablecoins-accordion-borrow-crypto-collateral-copy": "Con Ethereum, puoi prendere in prestito direttamente da altri utenti, senza scambiare i tuoi ETH. Questo può rappresentare un vantaggio: alcuni lo fanno per accumulare più ETH.", + "page-stablecoins-accordion-borrow-crypto-collateral-copy-p2": "Ma poiché il prezzo degli ETH è volatile, serviranno garanzie in più. Ciò significa che se desideri prendere in prestito 100 Stablecoin, necessiterai probabilmente di almeno $150 in ETH. Ciò protegge il sistema e i creditori.", + "page-stablecoins-accordion-borrow-crypto-collateral-link": "Di più sulle Stablecoin sostenute da criptovalute", "page-stablecoins-accordion-borrow-pill": "Avanzate", - "page-stablecoins-accordion-borrow-places-intro": "Queste dapp ti permettono di prendere in prestito stablecoin usando criptovalute come garanzia. Alcuni accettano altri token e anche ETH.", - "page-stablecoins-accordion-borrow-places-title": "Dove prendere in prestito stablecoin", - "page-stablecoins-accordion-borrow-requirement-1": "Un portafoglio Ethereum", - "page-stablecoins-accordion-borrow-requirement-1-description": "Servirà un portafoglio per usare una dapp", + "page-stablecoins-accordion-borrow-places-intro": "Queste dapp ti consentono di prendere in prestito delle Stablecoin, utilizzando le criptovalute come garanzia. Alcune accettano altre token, nonché ETH.", + "page-stablecoins-accordion-borrow-places-title": "Dove prendere Stablecoin in prestito", + "page-stablecoins-accordion-borrow-requirement-1": "Un portafoglio di Ethereum", + "page-stablecoins-accordion-borrow-requirement-1-description": "Necessiterai di un portafoglio per utilizzare una dapp", "page-stablecoins-accordion-borrow-requirement-2": "Ether (ETH)", - "page-stablecoins-accordion-borrow-requirement-2-description": "Serviranno ETH come garanzia e/o per le commissioni sulle transazioni", - "page-stablecoins-accordion-borrow-requirements-description": "Per prendere in prestito stablecoin servirà la dapp giusta. Avrai anche bisogno di un portafoglio e di alcuni ETH.", - "page-stablecoins-accordion-borrow-risks-copy": "Se usi ETH come garanzia e il relativo valore cala, la tua garanzia non coprirà gli stablecoin che hai generato. Questo causerà la liquidazione dei tuoi ETH e potresti subire una penale. Quindi se vuoi prendere in prestito stablecoin devi tenere d'occhio il prezzo di ETH.", - "page-stablecoins-accordion-borrow-risks-link": "Ultimo prezzo di ETH", + "page-stablecoins-accordion-borrow-requirement-2-description": "Necessiterai di degli ETH per la garanzia e/o per le commissioni sulle transazioni", + "page-stablecoins-accordion-borrow-requirements-description": "Per prendere in prestito delle Stablecoin, dovrai utilizzare la giusta dapp. Inoltre, necessiterai di un portafoglio e di degli ETH.", + "page-stablecoins-accordion-borrow-risks-copy": "Se utilizzi gli ETH come garanzia e il loro valore cala, la tua garanzia non coprirà le Stablecoin generate. Questo, causerà la liquidazione dei tuoi ETH e potresti incorrere in una penale. Quindi, se prendi in prestito delle Stablecoin, dovrai tenere d'occhio il prezzo degli ETH.", + "page-stablecoins-accordion-borrow-risks-link": "Prezzo di ETH più recente", "page-stablecoins-accordion-borrow-risks-title": "Rischi", - "page-stablecoins-accordion-borrow-text-preview": "Puoi prendere in prestito alcuni stablecoin usando criptovalute come garanzia, che dovrai ripagare.", + "page-stablecoins-accordion-borrow-text-preview": "Puoi prendere in prestito delle Stablecoin utilizzando le criptovalute come garanzia, che dovrai ripagare.", "page-stablecoins-accordion-borrow-title": "Prendi in prestito", - "page-stablecoins-accordion-buy-exchanges-title": "Borse popolari", - "page-stablecoins-accordion-buy-requirement-1": "Borse e portafogli di criptovalute", - "page-stablecoins-accordion-buy-requirement-1-description": "Controlla quali servizi puoi usare in base al luogo in cui vivi", - "page-stablecoins-accordion-buy-requirements-description": "Un conto con una borsa o un portafoglio da cui puoi acquistare direttamente le criptovalute. Potresti averne già usato qualcuno per ottenere degli ETH. Controlla quali servizi puoi utilizzare dove vivi.", - "page-stablecoins-accordion-buy-text-preview": "Molte borse e portafogli ti permettono di acquistare direttamente stablecoin. Potrebbero essere applicate restrizioni geografiche.", + "page-stablecoins-accordion-buy-exchanges-title": "Piattaforme di scambio popolari", + "page-stablecoins-accordion-buy-requirement-1": "Piattaforme di scambio e portafogli di criptovalute", + "page-stablecoins-accordion-buy-requirement-1-description": "Consulta i servizi che puoi utilizzare dove vivi", + "page-stablecoins-accordion-buy-requirements-description": "Un conto con una piattaforma di scambio o un portafoglio, da cui puoi acquistare criptovalute direttamente. Potresti averne già utilizzato qualcuno per ottenere degli ETH. Consulta quali servizi puoi utilizzare dove vivi.", + "page-stablecoins-accordion-buy-text-preview": "Molte piattaforme di scambio e portafogli ti consentono di acquistare direttamente le Stablecoin. Potrebbero essere applicate delle restrizioni geografiche.", "page-stablecoins-accordion-buy-title": "Acquista", - "page-stablecoins-accordion-buy-warning": "Le borse centralizzate potrebbero quotare solo stablecoin ancorati al valore di valute nazionali come USDC, Tether o altre. Potresti non essere in grado di acquistarli direttamente, ma dovresti essere in grado di scambiarli a fronte di ETH o altre criptovalute che puoi acquistare sulla piattaforma.", - "page-stablecoins-accordion-earn-project-1-description": "Soprattutto lavoro tecnico per il movimento del software open source.", - "page-stablecoins-accordion-earn-project-2-description": "Tecnologia, contenuti e altri lavori per la community MakerDao (il team che ha creato Dai).", - "page-stablecoins-accordion-earn-project-3-description": "Se davvero sai il fatto tuo, trova bug per guadagnare Dai.", - "page-stablecoins-accordion-earn-project-bounties": "Ricompense Gitcoin", - "page-stablecoins-accordion-earn-project-bug-bounties": "Ricompense per i bug sul livello di consenso", + "page-stablecoins-accordion-buy-warning": "Le piattaforme di scambio centralizzate potrebbero elencare soltanto Stablecoin supportate da valute legali, quali USDC, Tether e altre. Potresti non riuscire ad acquistarle direttamente, ma dovresti poterle scambiare da ETH o altre criptovalute, acquistabili sulla piattaforma.", + "page-stablecoins-accordion-earn-project-1-description": "Prevalentemente lavoro tecnico per il movimento dei software open source.", + "page-stablecoins-accordion-earn-project-2-description": "Tecnologia, contenuti e altri incarichi per la community di MakerDao (il team che ha creato DAI).", + "page-stablecoins-accordion-earn-project-3-description": "Se sai davvero il fatto tuo, trova i bug per guadagnare DAI.", + "page-stablecoins-accordion-earn-project-bounties": "Ricompense in Gitcoin", + "page-stablecoins-accordion-earn-project-bug-bounties": "\"Cacce ai bug\" del livello del consenso", "page-stablecoins-accordion-earn-project-community": "Community di MakerDao", - "page-stablecoins-accordion-earn-projects-copy": "Sono piattaforme che ti pagano in stablecoin per il tuo lavoro.", - "page-stablecoins-accordion-earn-projects-title": "Dove guadagnare stablecoin", + "page-stablecoins-accordion-earn-projects-copy": "Si tratta di piattaforme che ti pagheranno in Stablecoin per il tuo lavoro.", + "page-stablecoins-accordion-earn-projects-title": "Dove guadagnare delle Stablecoin", "page-stablecoins-accordion-earn-requirement-1": "Un portafoglio Ethereum", - "page-stablecoins-accordion-earn-requirement-1-description": "Ti servirà un portafoglio per ricevere gli stablecoin che guadagni", - "page-stablecoins-accordion-earn-requirements-description": "Gli stablecoin sono un ottimo metodo di pagamento per lavori o servizi, perché il loro valore è stabile. Ma ti servirà un portafoglio per ricevere i pagamenti.", - "page-stablecoins-accordion-earn-text-preview": "Puoi guadagnare stablecoin lavorando su progetti all'interno dell'ecosistema Ethereum.", + "page-stablecoins-accordion-earn-requirement-1-description": "Necessiterai di un portafoglio per ricevere le Stablecoin guadagnate", + "page-stablecoins-accordion-earn-requirements-description": "Le stablecoin sono un ottimo metodo di pagamento per lavori e servizi, poiché il loro valore è stabile. Ma necessiterai di un portafoglio per ricevere i pagamenti.", + "page-stablecoins-accordion-earn-text-preview": "Puo guadagnare delle Stablecoin lavorando a dei progetti, nell'ecosistema di Ethereum.", "page-stablecoins-accordion-earn-title": "Guadagna", "page-stablecoins-accordion-less": "Meno", "page-stablecoins-accordion-more": "Altro", "page-stablecoins-accordion-requirements": "Cosa ti servirà", - "page-stablecoins-accordion-swap-dapp-intro": "Se già possiedi ETH e un portafoglio, puoi usare queste dapp per scambiare stablecoin.", - "page-stablecoins-accordion-swap-dapp-link": "Scopri di più sulle borse decentralizzate", - "page-stablecoins-accordion-swap-dapp-title": "Dapp per scambiare token", - "page-stablecoins-accordion-swap-editors-tip": "Scelte degli editor", - "page-stablecoins-accordion-swap-editors-tip-button": "Trova portafogli", - "page-stablecoins-accordion-swap-editors-tip-copy": "Ottieni un portafoglio che ti permetta di acquistare ETH e scambiarli con token, inclusi gli stablecoin, direttamente.", - "page-stablecoins-accordion-swap-pill": "Raccomandato", + "page-stablecoins-accordion-swap-dapp-intro": "Se possiedi già degli ETH e un portafoglio, puoi utilizzare queste dapp per scambiarli con delle Stablecoin.", + "page-stablecoins-accordion-swap-dapp-link": "Di più sulle piattaforme di scambio decentralizzate", + "page-stablecoins-accordion-swap-dapp-title": "Dapp per scambiare i token", + "page-stablecoins-accordion-swap-editors-tip": "Consigli degli editori", + "page-stablecoins-accordion-swap-editors-tip-button": "Trova i portafogli", + "page-stablecoins-accordion-swap-editors-tip-copy": "Ottieni un portafoglio che ti consenta di acquistare ETH e scambiarli per dei token, Stablecoin incluse, direttamente.", + "page-stablecoins-accordion-swap-pill": "Consigliato", "page-stablecoins-accordion-swap-requirement-1": "Un portafoglio Ethereum", - "page-stablecoins-accordion-swap-requirement-1-description": "Ti servirà un portafoglio per autorizzare lo scambio e depositare le tue monete", + "page-stablecoins-accordion-swap-requirement-1-description": "Necessiterai di un portafoglio per autorizzare lo scambio e depositare le tue valute", "page-stablecoins-accordion-swap-requirement-2": "Ether (ETH)", "page-stablecoins-accordion-swap-requirement-2-description": "Per pagare lo scambio", - "page-stablecoins-accordion-swap-text-preview": "Puoi trovare la maggior parte degli stablecoin sulle borse decentralizzate. In questo modo, puoi scambiare tutti i tipi di token che hai con lo stablecoin che preferisci.", + "page-stablecoins-accordion-swap-text-preview": "Puoi selezionare gran parte delle Stablecoin sulle piattaforme di scambio decentralizzate. Quindi, puoi scambiare qualsiasi token che potresti possedere, per una Stablecoin che desideri.", "page-stablecoins-accordion-swap-title": "Scambia", - "page-stablecoins-algorithmic": "Algoritmico", + "page-stablecoins-algorithmic": "Algoritmica", "page-stablecoins-algorithmic-con-1": "Devi fidarti dell'algoritmo (o essere in grado di leggerlo).", - "page-stablecoins-algorithmic-con-2": "Il saldo delle tue monete cambierà in base alla quantità totale in circolazione.", - "page-stablecoins-algorithmic-description": "Questi stablecoin non sono supportati da nessun'altra risorsa. Un algoritmo venderà i token se il prezzo dovesse scendere sotto il valore desiderato o fornirà token se il valore dovesse salire oltre l'importo desiderato. Dato che il numero di questi token in circolazione cambia regolarmente, il numero dei token che possiedi cambierà, ma rispecchierà sempre la tua quota.", - "page-stablecoins-algorithmic-pro-1": "Non servono garanzie.", - "page-stablecoins-algorithmic-pro-2": "Controllato da un algoritmo pubblico.", + "page-stablecoins-algorithmic-con-2": "Il tuo saldo cambierà a seconda dell'offerta totale.", + "page-stablecoins-algorithmic-description": "Queste Stablecoin non sono sostenute da alcuna altra risorsa. Invece, un algoritmo venderà i token se il prezzo ricade sotto il valore desiderato e fornirà token se il valore supera l'importo desiderato. Poiché il numero di tali token in circolazione cambia regolarmente, il numero di token che possiedi cambierà, ma rifletterà sempre la tua quota.", + "page-stablecoins-algorithmic-pro-1": "Nessuna garanzia necessaria.", + "page-stablecoins-algorithmic-pro-2": "Controllata da un algoritmo pubblico.", "page-stablecoins-bank-apy": "0,05%", - "page-stablecoins-bank-apy-source": "Il tasso medio pagato dalle banche sui conti di risparmio di base, federalmente iscritti, negli USA.", + "page-stablecoins-bank-apy-source": "Il tasso medio pagato dalle banche su conti di risparmio di base, iscritti federalmente, negli Stati Uniti.", "page-stablecoins-bank-apy-source-link": "Fonte", "page-stablecoins-bitcoin-pizza": "La famigerata Pizza Bitcoin", - "page-stablecoins-bitcoin-pizza-body": "Nel 2010, qualcuno ha comprato 2 pizze pagandole 10.000 bitcoin. A quei tempi il valore era pari a circa 41 dollari. Ad oggi, equivarrebbero a milioni di dollari. Ci sono altri esempi di transazioni non proprio vantaggiose nella storia di Ethereum. Gli stablecoin risolvono questo problema, così puoi gustarti una buona pizza senza perdere ETH.", + "page-stablecoins-bitcoin-pizza-body": "Nel 2010, qualcuno acquistò 2 pizze per 10.000 bitcoin. Al tempo, il valore era pari a circa $37 EUR. Nel mercato odierno, equivarrebbero a milioni di dollari. Esistono simili transazioni non proprio vantaggiose, nella storia di Ethereum. Le Stablecoin risolvono tale problema, così che possa goderti la tua pizza, senza perdere i tuoi ETH.", "page-stablecoins-coin-price-change": "Variazione del prezzo della moneta (ultimi 30 giorni)", - "page-stablecoins-crypto-backed": "Basati su criptovalute", - "page-stablecoins-crypto-backed-con-1": "Meno stabili rispetto agli stablecoin ancorati al valore di valute nazionali.", + "page-stablecoins-crypto-backed": "Sostenuti da criptovalute", + "page-stablecoins-crypto-backed-con-1": "Meno stabili delle Stablecoin sostenute da valute legali.", "page-stablecoins-crypto-backed-con-2": "Devi tenere d'occhio il valore della garanzia della criptovaluta.", - "page-stablecoins-crypto-backed-description": "Questi stablecoin sono legati ad altre criptovalute, come ETH. Il loro prezzo dipende dal valore della risorsa sottostante (o garanzia), che può essere volatile. Siccome il valore di ETH può fluttuare, per questi stablecoin servono garanzie extra, per essere sicuri che il prezzo rimanga il più stabile possibile. Si potrebbe dire che il valore di 1$ di uno stablecoin basato su criptovaluta ha una risorsa criptovaluta sottostante del valore di almeno 2$. Quindi, se il prezzo di ETH dovesse scendere, dovranno essere utilizzati più ETH per sostenere il prezzo dello stablecoin; in caso contrario, lo stablecoin perderebbe il proprio valore.", - "page-stablecoins-crypto-backed-pro-1": "Trasparenti e completamente decentralizzati.", - "page-stablecoins-crypto-backed-pro-2": "Trasformabili rapidamente in altre criptovalute.", + "page-stablecoins-crypto-backed-description": "Queste Stablecoin sono sostenute da altre cripto-risorse, come gli ETH. Il loro prezzo dipende dal valore della risorsa sottostante (o garanzia), che può essere volatile. Poiché il valore degli ETH può fluttuare, per queste Stablecoin sono necessarie garanzie extra, per assicurarsi che il prezzo rimanga il più stabile possibile. Si potrebbe dre che il valore di 1$ di una Stablecoin sostenuta da criiptovalute, abbia una risorsa di criptovaluta sottostante dal valore di almeno 2$. Quindi, se il prezzo di ETH cala, devono essere utilizzati più ETH per sostenere la Stablecoin, altrimenti, queste, perderebbero il proprio valore.", + "page-stablecoins-crypto-backed-pro-1": "Trasparenti e completamente decentralizzate.", + "page-stablecoins-crypto-backed-pro-2": "Rapidamente trasformabili in altre risorse di criptovalute.", "page-stablecoins-crypto-backed-pro-3": "Nessun custode esterno: tutte le risorse sono controllate dai conti di Ethereum.", - "page-stablecoins-dai-banner-body": "Il Dai è probabilmente lo stablecoin decentralizzato più famoso. Il suo valore è circa di un dollaro ed è ampiamente accettato nelle dapp.", - "page-stablecoins-dai-banner-learn-button": "Scopri di più sul Dai", - "page-stablecoins-dai-banner-swap-button": "Scambia ETH per Dai", - "page-stablecoins-dai-banner-title": "Dai", - "page-stablecoins-dai-logo": "Logo Dai", - "page-stablecoins-editors-choice": "Scelti da noi", - "page-stablecoins-editors-choice-intro": "Sono probabilmente gli esempi più noti al momento di stablecoin e delle monete che abbiamo trovato utili per l'uso delle dapp.", + "page-stablecoins-dai-banner-body": "DAI è probabilmente la Stablecoin decentralizzata più famosa. Il suo valore è di circa un dollaro ed è ampiamente accettata tra le varie dapp.", + "page-stablecoins-dai-banner-learn-button": "Impara su DAI", + "page-stablecoins-dai-banner-swap-button": "Scambia ETH per DAI", + "page-stablecoins-dai-banner-title": "DAI", + "page-stablecoins-dai-logo": "Il logo di DAI", + "page-stablecoins-editors-choice": "Le scelte degli editori", + "page-stablecoins-editors-choice-intro": "Questi sono probabilmente gli esempi più noti di Stablecoin al momento, nonché le monete che riteniamo utili, per l'utilizzo delle dapp.", "page-stablecoins-explore-dapps": "Esplora le dapp", - "page-stablecoins-fiat-backed": "Ancorato al valore delle valute nazionali", - "page-stablecoins-fiat-backed-con-1": "Centralizzato: qualcuno deve rilasciare i token.", - "page-stablecoins-fiat-backed-con-2": "Richiede un controllo per assicurare che l'azienda abbia sufficienti riserve.", - "page-stablecoins-fiat-backed-description": "Fondamentalmente un \"pagherò\" per una valuta tradizionale (di solito dollari). Usi la tua valuta legale per acquistare un tipo di stablecoin che poi potrai incassare successivamente e riscattare con la tua valuta originale.", - "page-stablecoins-fiat-backed-pro-1": "Sicuro contro la volatilità tipica delle criptovalute.", + "page-stablecoins-fiat-backed": "Sostenute da valute legali", + "page-stablecoins-fiat-backed-con-1": "Centralizzata: qualcuno deve emettere i token.", + "page-stablecoins-fiat-backed-con-2": "Richiede il controllo, per assicurarsi che l'azienda abbia riserve sufficienti.", + "page-stablecoins-fiat-backed-description": "Fondamentalmente una cambiale per una valuta legale tradizionale (solitamente, i dollari). Utilizzi la tua valuta legale per acquistare una Stablecoin, che puoi successivamente incassare e riscattare, per la tua valuta originale.", + "page-stablecoins-fiat-backed-pro-1": "Sicure contro la volatilità delle criptovalute.", "page-stablecoins-fiat-backed-pro-2": "Le variazioni di prezzo sono minime.", - "page-stablecoins-find-stablecoin": "Trova uno stablecoin", - "page-stablecoins-find-stablecoin-how-to-get-them": "Come ottenere stablecoin", - "page-stablecoins-find-stablecoin-intro": "Sono disponibili centinaia di stablecoin. Qui te ne mostriamo alcuni per aiutarti a muovere i primi passi. Se non conosci ancora il mondo Ethereum, ti raccomandiamo di fare prima qualche ricerca.", + "page-stablecoins-find-stablecoin": "Trova una Stablecoin", + "page-stablecoins-find-stablecoin-how-to-get-them": "Come ottenere le stablecoin", + "page-stablecoins-find-stablecoin-intro": "Sono disponibili centinaia di Stablecoin. Eccone alcune per aiutarti a muovere i primi passi. Se sei nuovo su Ethereum, ti consigliamo di fare prima qualche ricerca.", "page-stablecoins-find-stablecoin-types-link": "Diversi tipi di stablecoin", "page-stablecoins-get-stablecoins": "Come ottenere stablecoin", - "page-stablecoins-hero-alt": "I tre maggiori stablecoin per capitalizzazione: Dai, USDC e Tether.", - "page-stablecoins-hero-button": "Ottieni stablecoin", - "page-stablecoins-hero-header": "Moneta digitale per l'utilizzo quotidiano", - "page-stablecoins-hero-subtitle": "Gli stablecoin sono token Ethereum progettati per mantenere un valore fisso, anche quando il prezzo di ETH cambia.", - "page-stablecoins-interest-earning-dapps": "Dapp che permettono di maturare interessi", - "page-stablecoins-meta-description": "Introduzione agli stablecoin Ethereum: cosa sono, come ottenerli e perché sono importanti.", + "page-stablecoins-hero-alt": "Le tre Stablecoin principali per capitalizzazione di mercato: DAI, USDC e Tether.", + "page-stablecoins-hero-button": "Ottieni delle stablecoin", + "page-stablecoins-hero-header": "Denaro digitale per l'utilizzo quotidiano", + "page-stablecoins-hero-subtitle": "Le Stablecoin sono token di Ethereum, progettati per mantenere un valore fisso, anche al cambiare del prezzo degli ETH.", + "page-stablecoins-interest-earning-dapps": "Dapp di maturazione degli interessi", + "page-stablecoins-meta-description": "Un'introduzione alle Stablecoin di Ethereum: cosa sono, come ottenerle e perché sono importanti.", "page-stablecoins-precious-metals": "Metalli preziosi", "page-stablecoins-precious-metals-con-1": "Centralizzati: qualcuno deve emettere i token.", - "page-stablecoins-precious-metals-con-2": "Devi fidarti dell'emittente dei token e delle riserve di metallo prezioso.", - "page-stablecoins-precious-metals-description": "Come le monete ancorate al valore di valute nazionali, questi stablecoin usano risorse come l'oro per mantenere stabile il proprio valore.", + "page-stablecoins-precious-metals-con-2": "Devi fidarti dell'emittente del token e delle riserve del metallo prezioso.", + "page-stablecoins-precious-metals-description": "Come le monete sostenute dalle valute legali, queste Stablecoin utilizzano risorse come l'oro, per mantenere il proprio valore.", "page-stablecoins-precious-metals-pro-1": "Protetti dalla volatilità delle criptovalute.", - "page-stablecoins-prices": "Prezzi degli stablecoin", - "page-stablecoins-prices-definition": "Gli stablecoin sono criptovalute non soggette a volatilità. Possiedono molte delle peculiarità di ETH ma il loro valore è stabile, similmente alle valute tradizionali. Quindi hai accesso a moneta stabile che puoi utilizzare su Ethereum. ", - "page-stablecoins-prices-definition-how": "Come viene garantita la stabilità degli stablecoin", - "page-stablecoins-research-warning": "Ethereum è una nuova tecnologia e la maggior parte delle applicazioni è nuova. Assicurati di essere consapevole dei rischi e deposita solo somme che puoi permetterti di perdere.", + "page-stablecoins-prices": "Prezzi delle Stablecoin", + "page-stablecoins-prices-definition": "Le Stablecoin sono criptovalute prive di volatilità. Condividono molte delle peculiarità degli ETH, ma il loro valore è stabile, similmente alle valute tradizionali. Così, hai accesso a una moneta stabile, utilizzabile su Ethereum. ", + "page-stablecoins-prices-definition-how": "Come viene garantita la stabilità delle Stablecoin", + "page-stablecoins-research-warning": "Ethereum è una nuova tecnologia e, gran parte delle applicazioni, sono nuove. Assicurati di essere a conoscenza dei rischi e deposita soltanto ciò che puoi permetterti di perdere.", "page-stablecoins-research-warning-title": "Fai sempre le tue ricerche di verifica", - "page-stablecoins-save-stablecoins": "Risparmio con gli stablecoin", - "page-stablecoins-save-stablecoins-body": "Gli stablecoin hanno solitamente un tasso di interesse più alto della media perché c'è molta domanda per prenderli in prestito. Queste sono dapp che permettono di ottenere interessi sugli stablecoin in tempo reale depositandoli in un pool di prestiti. Proprio come nel mondo bancario, fornisci token a chi li richiede in prestito ma potrai comunque prelevarli, insieme agli interessi, in qualsiasi momento.", - "page-stablecoins-saving": "Metti a frutto le tue riserve di stablecoin e guadagna interessi. Come sempre nel mondo delle criptovalute, il rendimento annuo percentuale (APY, Annual Percentage Yields) può cambiare giornalmente a seconda della domanda e dell'offerta in tempo reale.", - "page-stablecoins-stablecoins-dapp-callout-description": "Dai un occhio alle dapp Ethereum. Gli stablecoin sono spesso più utili per le transazioni quotidiane.", - "page-stablecoins-stablecoins-dapp-callout-image-alt": "Figura di un cane.", - "page-stablecoins-stablecoins-dapp-callout-title": "Usa i tuoi stablecoin", - "page-stablecoins-stablecoins-dapp-description-1": "Piazze di scambio per molti stablecoin, tra cui Dai, USDC, TUSD, USDT e altri. ", - "page-stablecoins-stablecoins-dapp-description-2": "Presta stablecoin e guadagna interessi e $COMP, il token proprietario di Compound.", - "page-stablecoins-stablecoins-dapp-description-3": "Piattaforma di trading dove puoi guadagnare interessi sui tuoi Dai e USDC.", - "page-stablecoins-stablecoins-dapp-description-4": "App progettata per risparmiare Dai.", - "page-stablecoins-stablecoins-feature-1": "Gli stablecoin sono globali e possono essere inviati via Internet. Una volta ottenuto un conto di Ethereum, sono semplici da ricevere o inviare.", - "page-stablecoins-stablecoins-feature-2": "La domanda di stablecoin è alta, quindi puoi guadagnare interessi prestando i tuoi. Assicurati di essere a conoscenza dei rischi prima di procedere al prestito.", - "page-stablecoins-stablecoins-feature-3": "Gli stablecoin sono scambiabili con ETH e altri token Ethereum. Molte dapp si basano su stablecoin.", - "page-stablecoins-stablecoins-feature-4": "Gli stablecoin sono protetti dalla crittografia. Nessuno può fare transazioni per tuo conto.", + "page-stablecoins-save-stablecoins": "Risparmia con le Stablecoin", + "page-stablecoins-save-stablecoins-body": "Spesso, le Stablecoin, hanno un tasso di interesse superiore alla media, poiché vi è molta domanda per prenderle in prestito. Esistono delle dapp che consentono di maturare interessi sulle tue Stablecoin in tempo reale, depositandole in un gruppo di prestito. Proprio come nel mondo bancario, stai fornendo token ai debitori, ma puoi prelevarli, insieme ai tuoi interessi, in qualsiasi momento.", + "page-stablecoins-saving": "Metti a frutto i tuoi risparmi di Stablecoin e matura interessi. Come sempre, nel mondo delle criptovalute, il Rendimento Annuo Percentuale (APY), può cambiare giornalmente, a seconda della domanda e dell'offerta in tempo reale.", + "page-stablecoins-stablecoins-dapp-callout-description": "Dai un'occhiata alle dapp di Ethereum: le Stablecoin sono spesso più utili per le transazioni quotidiane.", + "page-stablecoins-stablecoins-dapp-callout-image-alt": "Illustrazione di un cane di razza doge.", + "page-stablecoins-stablecoins-dapp-callout-title": "Controlla le tue Stablecoin", + "page-stablecoins-stablecoins-dapp-description-1": "Mercati per molte Stablecoin, tra cui DAI, USDC, TUSD, USDT e altre. ", + "page-stablecoins-stablecoins-dapp-description-2": "Presta stablecoin e matura interessi e $COMP, il token di Compound.", + "page-stablecoins-stablecoins-dapp-description-3": "Una piattaforma di trading in cui puoi maturare interessi sulle tue DAI e USDC.", + "page-stablecoins-stablecoins-dapp-description-4": "Un'app progettata per risparmiare sulle DAI.", + "page-stablecoins-stablecoins-feature-1": "Le Stablecoin sono globali e possono essere inviate via Internet. Sono facili da ricevere e inviare, una volta che possiedi un conto di Ethereum.", + "page-stablecoins-stablecoins-feature-2": "La domanda per le Stablecoin è elevata, quindi, puoi maturare interessi, prestando le tue. Assicurati di essere consapevole dei rischi, prima di procedere al prestito.", + "page-stablecoins-stablecoins-feature-3": "Le stablecoin sono scambiabili per ETH e altri token di Ethereum. Molte dapp si affidano alle stablecoin.", + "page-stablecoins-stablecoins-feature-4": "Le Stablecoin sono protette dalla crittografia. Nessuno può forgiare transazioni per tuo conto.", "page-stablecoins-stablecoins-meta-description": "Introduzione agli stablecoin Ethereum: cosa sono, come ottenerli e perché sono importanti.", "page-stablecoins-stablecoins-table-header-column-1": "Valuta", "page-stablecoins-stablecoins-table-header-column-2": "Capitalizzazione di mercato", "page-stablecoins-stablecoins-table-header-column-3": "Tipo di garanzia", "page-stablecoins-stablecoins-table-type-crypto-backed": "Criptovaluta", - "page-stablecoins-stablecoins-table-type-fiat-backed": "Valuta a corso legale", + "page-stablecoins-stablecoins-table-type-fiat-backed": "Valuta legale", "page-stablecoins-stablecoins-table-type-precious-metals-backed": "Metalli preziosi", - "page-stablecoins-table-error": "Impossibile caricare stablecoin. Prova ad aggiornare la pagina.", - "page-stablecoins-table-loading": "Caricamento dati stablecoin in corso...", + "page-stablecoins-table-error": "Impossibile caricare le Stablecoin. Prova ad aggiornare la pagina.", + "page-stablecoins-table-loading": "Caricamento dei dati delle Stablecoin...", "page-stablecoins-title": "Stablecoin", - "page-stablecoins-top-coins": "Principali stablecoin per capitalizzazione di mercato", + "page-stablecoins-top-coins": "Stablecoin più popolari per capitalizzazioni di mercato", "page-stablecoins-top-coins-intro": "La capitalizzazione di mercato è", - "page-stablecoins-top-coins-intro-code": "il numero totale di token esistenti moltiplicato per il valore del token. Questa lista è dinamica e i progetti elencati qui non sono necessariamente approvati dal team di ethereum.org.", + "page-stablecoins-top-coins-intro-code": "il numero totale di token esistenti, moltiplicato per il valore per token. Questo elenco è dinamico e i progetti qui elencati non sono necessariamente sponsorizzati dal team di ethereum.org.", "page-stablecoins-types-of-stablecoin": "Come funzionano: tipi di stablecoin", - "page-stablecoins-usdc-banner-body": "USDC è probabilmente il più famoso tra gli stablecoin ancorati al valore di valute nazionali. Vale circa un dollaro ed è basato su Circle e Coinbase.", + "page-stablecoins-usdc-banner-body": "USDC è probabilmente la Stablecoin sostenuta da valuta legale più famosa. Il suo valore è approssimativamente di un dollaro, e si basa su Circle e Coinbase.", "page-stablecoins-usdc-banner-learn-button": "Scopri di più su USDC", "page-stablecoins-usdc-banner-swap-button": "Scambia ETH per USDC", "page-stablecoins-usdc-banner-title": "USDC", - "page-stablecoins-usdc-logo": "Logo USDC", + "page-stablecoins-usdc-logo": "Il logo di USDC", "page-stablecoins-why-stablecoins": "Perché stablecoin?", "page-stablecoins-how-they-work-button": "Come funzionano", - "page-stablecoins-why-stablecoins-body": "ETH, come Bitcoin, ha un prezzo volatile perché è una nuova tecnologia. Quindi potrebbe essere consigliabile non spenderlo regolarmente. Gli stablecoin rispecchiano il valore delle valute tradizionali per dare accesso a una moneta stabile che puoi usare su Ethereum.", - "page-stablecoins-more-defi-button": "Maggiori informazioni sulla finanza decentralizzata (DeFi)", - "page-stablecoins-tools-title": "Scopri di più sugli stablecoin", - "page-stablecoins-tools-stablecoinswtf-description": "Stablecoins.wtf offre un pannello di controllo con dati di mercato storici, statistiche e contenuti educativi per gli stablecoin più importanti.", + "page-stablecoins-why-stablecoins-body": "ETH, come Bitcoin, ha un prezzo volatile perché è una nuova tecnologia. Quindi, potresti non volerne spendere in modo regolare. Le Stablecoin rispecchiano il valore delle valute tradizionali, per darti accesso a denaro stabile, utilizzabile su Ethereum.", + "page-stablecoins-more-defi-button": "Di più sulla finanza decentralizzata (DeFi)", + "page-stablecoins-tools-title": "Impara di più sulle Stablecoin", + "page-stablecoins-tools-stablecoinswtf-description": "Stablecoins.wtf offre un pannello di controllo con dati di mercato storici, statistiche e contenuti educativi, per le Stablecoin più importanti.", "page-dapps-ready-button": "Via!", "pros": "Pro", "cons": "Contro", - "1inch-logo": "Logo 1inch", - "aave-logo": "Logo Aave", - "binance-logo": "Logo Binance", - "bittrex-logo": "Logo Bittrex", - "coinbase-logo": "Logo Coinbase", - "coinmama-logo": "Logo Coinmama", - "compound-logo": "Logo Compound", + "1inch-logo": "Logo di 1inch", + "aave-logo": "Logo di Aave", + "binance-logo": "Logo di Binance", + "bittrex-logo": "Logo di Bittrex", + "coinbase-logo": "Logo di Coinbase", + "coinmama-logo": "Logo di Coinmama", + "compound-logo": "Logo di Compound", "example-projects": "Progetti di esempio", - "gemini-logo": "Logo Gemini", - "gitcoin-logo": "Logo Gitcoin", - "loopring-logo": "Logo Loopring", - "makerdao-logo": "Logo MakerDao", - "matcha-logo": "Logo Matcha", - "oasis-logo": "Logo Oasis", - "uniswap-logo": "Logo Uniswap" + "gemini-logo": "Logo di Gemini", + "gitcoin-logo": "Logo di Gitcoin", + "loopring-logo": "Logo di Loopring", + "makerdao-logo": "Logo di MakerDao", + "matcha-logo": "Logo di Matcha", + "oasis-logo": "Logo di Oasis", + "uniswap-logo": "Logo di Uniswap" } diff --git a/src/intl/it/page-staking.json b/src/intl/it/page-staking.json index f1974bb0b29..9ee972e2169 100644 --- a/src/intl/it/page-staking.json +++ b/src/intl/it/page-staking.json @@ -1,11 +1,30 @@ { + "comp-withdrawal-comparison-current-title": "Staker attuali", + "comp-withdrawal-comparison-current-li-1": "Alcuni utenti potrebbero aver fornito un indirizzo di prelievo alla prima configurazione del proprio deposito di staking; questi utenti non devono fare altro", + "comp-withdrawal-comparison-current-li-2": "Gran parte degli staker non ha fornito un indirizzo di prelievo al deposito iniziale, e dovrà aggiornare le proprie credenziali di prelievo. Il Launchpad di Staking contiene le istruzioni su come farlo", + "comp-withdrawal-comparison-current-p": "Qui puoi inserire il numero del tuo indice del validatore per verificare se devi ancora aggiornare le tue credenziali (lo puoi trovare nei log del tuo client):", + "comp-withdrawal-comparison-new-title": "Nuovi staker (che non hanno ancora depositato)", + "comp-withdrawal-comparison-new-li-1": "Di default, i nuovi staker che cercano di abilitare automaticamente i pagamenti delle ricompense e la funzionalità di prelievo dovrebbero fornire un indirizzo di prelievo di Ethereum che controllano quando generano le chiavi del validatore utilizzando lo strumento Staking Deposit CLI", + "comp-withdrawal-comparison-new-li-2": "Ciò non è necessario al momento del deposito, ma farà sì che non sia necessario aggiornare tali chiavi in seguito per sbloccare i propri fondi", + "comp-withdrawal-comparison-new-p": "Il Launchpad di Staking ti guiderà nello staking.", + "comp-withdrawal-comparison-new-link": "Visita il Launchpad di Staking", + "comp-withdrawal-credentials-placeholder": "Indice del validatore", + "comp-withdrawal-credentials-error": "Ops! Ricontrolla il numero di indice del validatore e riprova.", + "comp-withdrawal-credentials-upgraded-1": "L'indice del validatore {{validatorIndex}} è pronto per iniziare a ricevere ricompense!", + "comp-withdrawal-credentials-upgraded-2": "Credenziali di prelievo collegate all'indirizzo di esecuzione:", + "comp-withdrawal-credentials-not-upgraded-1": "Questo validatore deve essere aggiornato.", + "comp-withdrawal-credentials-not-upgraded-1-testnet": "Il validatore della rete di prova di Goerli deve essere aggiornato.", + "comp-withdrawal-credentials-not-upgraded-2": "Le istruzioni su come aggiornarlo sono attualmente disponibili sul Launchpad di Staking", + "comp-withdrawal-credentials-verify-mainnet": "Verifica sulla Rete Principale", + "comp-withdrawal-credentials-verify-goerli": "Verifica su Goerli", + "page-staking-withdrawals-when": "Spedita!", "page-staking-image-alt": "Immagine della mascotte Rhino per il launchpad di staking.", "page-staking-benefits-1-title": "Ottieni ricompense", "page-staking-benefits-1-description": "Le ricompense sono date per azioni che aiutano la rete a raggiungere il consenso. Otterrai ricompense per l'esecuzione di software che raggruppano propriamente le transazioni in nuovi blocchi e che verificano il lavoro di altri validatori, perché è questo quello che mantiene l'esecuzione della catena in sicurezza.", "page-staking-benefits-2-title": "Migliore sicurezza", "page-staking-benefits-2-description": "La rete diventa più forte contro gli attacchi allo staking di più ETH, poiché poi richiede altri ETH per controllare una maggioranza della rete. Per diventare una minaccia, dovresti detenere la maggioranza dei validatori, il che significa che dovresti controllare la maggioranza degli ETH nel sistema, e sono molti!", "page-staking-benefits-3-title": "Più sostenibile", - "page-staking-benefits-3-description": "Gli staker non necessitano di computer ad alta potenza per partecipare al sistema di proof-of-stake, basta un computer fisso o uno smartphone. Questo renderà Ethereum migliore per l'ambiente.", + "page-staking-benefits-3-description": "Gli staker non devono eseguire calcoli di proof-of-work ad alto consumo energetico per partecipare alla protezione della rete, il che significa che i nodi di staking possono essere eseguiti su hardware relativamente modesti consumando pochissima energia.", "page-staking-benefits-3-link": "Di più sul consumo energetico di Ethereum", "page-staking-description": "Lo staking è l'atto di depositare 32 ETH per attivare il software del validatore. In qualità di validatore, sarai responsabile dell'archiviazione dei dati, dell'elaborazione delle transazioni e dell'aggiunta di nuovi blocchi alla blockchain. Questo proteggerà Ethereum per tutti e ti farà guadagnare nuovi ETH nel processo.", "page-staking-hero-title": "Come fare staking con i tuoi ETH", @@ -21,6 +40,7 @@ "page-staking-learn-more-saas": "Scopri di più sullo staking come un servizio", "page-staking-dropdown-pools": "Staking in pool", "page-staking-dropdown-withdrawals": "Informazioni sui prelievi", + "page-staking-dropdown-dvt": "Tecnologia del validatore distribuita", "page-staking-more-on-pools": "Di più sullo staking in pool", "page-staking-learn-more-pools": "Scopri di più sullo staking in pool", "page-staking-section-what-title": "Cos'è lo staking?", @@ -130,6 +150,9 @@ "page-staking-stats-box-metric-1": "ETH in staking totali", "page-staking-stats-box-metric-2": "Validatori totali", "page-staking-stats-box-metric-3": "APR corrente", + "page-staking-stats-box-metric-1-tooltip": "Somma di ETH in staking sulla Beacon Chain, esclusi i saldi superiori a 32 ETH", + "page-staking-stats-box-metric-2-tooltip": "Numero di conti dei validatori attualmente attivati sulla Beacon Chain", + "page-staking-stats-box-metric-3-tooltip": "Rendimento finanziario annualizzato medio per validatore nelle ultime 24 ore", "page-staking-section-comparison-subtitle": "Non esiste una soluzione univoca per lo staking e ognuna è unica. Qui confronteremo alcuni dei rischi, delle ricompense e dei requisiti dei diversi metodi in cui puoi fare staking.", "page-staking-section-comparison-rewards-title": "Ricompense", "page-staking-section-comparison-solo-rewards-li1": "Ricompense massime: ricevi ricompense complete direttamente dal protocollo", @@ -167,10 +190,10 @@ "page-staking-faq-4-question": "Lo staking è già attivo?", "page-staking-faq-4-answer-p1": "Sì. Lo staking è attivo dall'1 dicembre 2020", "page-staking-faq-4-answer-p2": "Ciò significa che lo staking è correntemente operativo: gli utenti possono depositare i propri ETH, operare un client validatore e iniziare a guadagnare ricompense.", - "page-staking-faq-4-answer-p3": "La Fusione è avvenuta il 15 settembre 2022 e, da allora, Ethereum è stato pienamente protetto dagli ETH in staking.", + "page-staking-faq-4-answer-p3": "L'aggiornamento di Shanghai/Capella è stato completato il 12 aprile 2023, consentendo i prelievi di staking e chiudendo il ciclo sulla liquidità di staking.", "page-staking-faq-5-question": "Quando potrò prelevare i miei ETH in staking?", - "page-staking-faq-5-answer-p1": "La funzionalità di prelievo dovrebbe essere inclusa nel prossimo aggiornamento della rete, denominato Shanghai. Questo aggiornamento della rete è stimato per la prima metà del 2023, con riserva di modifiche fino al completamento. Dopo l'aggiornamento di Shanghai, gli staker potranno prelevare le proprie ricompense e/o deposito principale dal saldo del proprio validatore, se lo desidereranno.", - "page-staking-faq-5-answer-p2": "Nel frattempo, gli staker guadagneranno comunque le ricompense, nella forma di commissioni e MEV alla proposta di blocchi, che sono rese disponibili immediatamente, tramite l'indirizzo del destinatario della commissione impostato.", + "page-staking-faq-5-answer-p1": "Subito! Gli staker sono liberi di prelevare le proprie ricompense e/o i propri depositi principali dal proprio saldo del validatore se lo desiderano.", + "page-staking-faq-5-answer-p2": "Gli staker guadagneranno ricompense anche sotto forma di commissioni e MEV quando propongono blocchi; queste sono rese disponibili immediatamente tramite l’indirizzo del destinatario della commissione impostato.", "page-staking-faq-5-answer-link": "Di più sui prelievi di staking", "page-staking-further-reading-1-link": "Perché il Proof of Stake (Nov 2020)", "page-staking-further-reading-author-vitalik-buterin": "Vitalik Buterin", @@ -196,5 +219,6 @@ "page-staking-meta-title": "Staking su Ethereum", "page-staking-withdrawals-important-notices": "Avvisi importanti", "page-staking-withdrawals-important-notices-desc": "I prelievi non sono ancora disponibili. Per ulteriori informazioni, si prega di leggere le FAQ sulla fusione e post-fusione di Eth2.", - "page-upgrades-merge-btn": "Maggiori informazioni sulla fusione" + "page-upgrades-merge-btn": "Maggiori informazioni sulla fusione", + "subscribe-to-ef-blog": "Iscriviti al Blog della EF per ricevere notifiche email per gli annunci più recenti sul protocollo." } diff --git a/src/intl/it/page-upgrades-get-involved-bug-bounty.json b/src/intl/it/page-upgrades-get-involved-bug-bounty.json new file mode 100644 index 00000000000..8abaed05d24 --- /dev/null +++ b/src/intl/it/page-upgrades-get-involved-bug-bounty.json @@ -0,0 +1,47 @@ +{ + "page-upgrades-get-involved-btn-1": "Vedi client", + "page-upgrades-get-involved-btn-2": "Maggiori informazioni sullo staking", + "page-upgrades-get-involved-btn-3": "Trova bug", + "page-upgrades-get-involved-bug": "Un bug potrebbe essere:", + "page-upgrades-get-involved-bug-hunting": "Alla ricerca di bug", + "page-upgrades-get-involved-bug-hunting-desc": "Trova e segnala i bug nelle specifiche dell'aggiornamento del livello del consenso o dei client stessi. Puoi guadagnare fino a 50.000 USD e raggiungere un posto sulla classifica.", + "page-upgrades-get-involved-bug-li": "problemi di non conformità della specifica", + "page-upgrades-get-involved-bug-li-2": "bug che infrangono la finalità", + "page-upgrades-get-involved-bug-li-3": "vettori denial of service (DOS)", + "page-upgrades-get-involved-bug-li-4": "e molto altro...", + "page-upgrades-get-involved-desc-1": "Eseguire un client significa essere un partecipante attivo di Ethereum. Il client aiuterà a tenere traccia delle transazioni e controllare nuovi blocchi.", + "page-upgrades-get-involved-desc-2": "Se hai ETH, puoi fare staking per diventare un validatore e contribuire a proteggere la rete. Come validatore puoi ottenere ricompense in ETH.", + "page-upgrades-get-involved-desc-3": "Unisciti agli sforzi di test della community! Aiuta a provare gli aggiornamenti di Ethereum prima che siano rilasciati, trova bug e guadagna ricompense.", + "page-upgrades-get-involved-ethresearch-1": "Sharding", + "page-upgrades-get-involved-ethresearch-2": "La fusione", + "page-upgrades-get-involved-ethresearch-3": "Esecuzione frammentata", + "page-upgrades-get-involved-ethresearch-4": "Tutti gli argomenti di ricerca", + "page-upgrades-get-involved-how": "Come vuoi partecipare?", + "page-upgrades-get-involved-how-desc": "La community di Ethereum ne beneficerà se un maggior numero di persone esegue i client, fa staking e cerca bug.", + "page-upgrades-get-involved-join": "Unisciti alla ricerca", + "page-upgrades-get-involved-join-desc": "Come gran parte delle cose su Ethereum, molta ricerca è pubblica. Ciò significa che puoi prendere parte alle discussioni o semplicemente leggere ciò che i ricercatori di Ethereum hanno da dire. ethresear.ch copre numerosi argomenti, inclusi gli aggiornamenti del consenso, i rollup e molto altro.", + "page-upgrades-get-involved-meta-description": "Come partecipare agli aggiornamenti di Ethereum: eseguire nodi, stake, cacciare bug e altro.", + "page-upgrades-get-involved-run-clients": "Esegui una coppia di client", + "page-upgrades-get-involved-run-clients-desc": "Un 'client' è il software che esegue la blockchain e, nel caso di Ethereum, un nodo completo necessita di operare una coppia di client: uno del livello d'esecuzione e uno del livello di consenso. Un nodo completo può verificare le transazioni e, se ha anche ETH in staking, può creare nuovi blocchi. Ogni client ha le proprie funzionalità ma esegue, nel complesso, la stessa funzione, quindi ti incoraggiamo a scegliere un client di minoranza quando possibile, per mantenere diverso e sicuro il pool del client.", + "page-upgrades-get-involved-run-clients-desc-link": "Maggiori informazioni sulla diversità del client.", + "page-upgrades-get-involved-run-clients-execution": "Client del livello d'esecuzione", + "page-upgrades-get-involved-run-clients-execution-desc": "Questi client erano precedentemente definiti client di 'Eth1', ma questo termine è stato deprecato in favore di client del 'livello d'esecuzione'.", + "page-upgrades-get-involved-run-clients-consensus": "Client del livello di consenso", + "page-upgrades-get-involved-run-clients-consensus-desc": "Questi client erano precedentemente definiti client di 'Eth2', ma questo termine è stato deprecato in favore di client del 'livello del consenso'.", + "page-upgrades-get-involved-stake": "Fai staking con i tuoi ETH", + "page-upgrades-get-involved-stake-desc": "Ora puoi fare staking con i tuoi ETH per contribuire a proteggere la beacon chain.", + "page-upgrades-get-involved-stake-eth": "Fai staking con gli ETH", + "page-upgrades-get-involved-subtitle": "Ecco tutti i modi in cui puoi aiutare con Ethereum e gli sforzi futuri correlati agli aggiornamenti.", + "page-upgrades-get-involved-title-1": "Esegui un client", + "page-upgrades-get-involved-title-2": "Fai staking con i tuoi ETH", + "page-upgrades-get-involved-title-3": "Trova bug", + "page-upgrades-get-involved-written-c-sharp": "Scritto in C#", + "page-upgrades-get-involved-written-go": "Scritto in Go", + "page-upgrades-get-involved-written-java": "Scritto in Java", + "page-upgrades-get-involved-written-javascript": "Scritto in JavaScript", + "page-upgrades-get-involved-written-nim": "Scritto in Nim", + "page-upgrades-get-involved-written-rust": "Scritto in Rust", + "page-upgrades-get-involved": "Partecipa all'aggiornamento di Ethereum", + "page-upgrades-get-involved-2": "Partecipa", + "page-upgrades-bug-bounty-leaderboard-points": "punti" +} diff --git a/src/intl/it/page-upgrades-index.json b/src/intl/it/page-upgrades-index.json index 3fe6af9b44c..adc9f241f08 100644 --- a/src/intl/it/page-upgrades-index.json +++ b/src/intl/it/page-upgrades-index.json @@ -150,7 +150,7 @@ "page-upgrades-secure": "Più sicura", "page-upgrades-secure-desc": "Ethereum deve essere più sicura; man mano che l'adozione di Ethereum aumenta, il protocollo deve essere più protetto da tutte le forme di attacco.", "page-upgrades-shard-date": "Lo sharding seguirà La Fusione in più fasi, tra il 2023 e il 2024.", - "page-upgrades-shard-desc": "Lo sharding espanderà la capacità di Ethereum di memorizzare dati e opererà in armonia con i L2 per scalare il volume e ridurre le commissioni della rete. Lo sharding sarà lanciato in diverse fasi.", + "page-upgrades-shard-desc": "Danksharding espanderà la capacità di Ethereum di immagazzinare dati e lavorare in armonia con L2 per scalare la portata e ridurre i costi di rete. Danksharding verrà implementato in più fasi, a partire da ProtoDanksharding.", "page-upgrades-shard-estimate": "Stima: 2023-2024", "page-upgrades-shard-lower": "Maggiori informazioni sullo sharding", "page-upgrades-shard-title": "Sharding", @@ -170,8 +170,8 @@ "page-upgrades-upgrades-docking": "La fusione", "page-upgrades-energy-consumption": "Maggiori informazioni sul consumo energetico di Ethereum", "page-upgrades-upgrading": "Aggiornare Ethereum a nuovi livelli", - "page-roadmap-vision": "La vision", - "page-roadmap-vision-btn": "Di più sulla visione di Ethereum", + "page-roadmap-vision": "La visione", + "page-roadmap-vision-btn": "Maggiori informazioni sulla visione di Ethereum", "page-roadmap-vision-desc": "Per portare Ethereum nella rete principale e servire tutta l'umanità, dobbiamo rendere Ethereum più scalabile, sicura e sostenibile.", "page-upgrades-what-happened-to-eth2-title": "Che è successo a 'Eth2?'", "page-upgrades-what-happened-to-eth2-1": "Il termine 'Eth2' era comunemente usato prima della Fusione, ma è in fase di graduale eliminazione in favore di una terminologia più precisa.", @@ -203,5 +203,5 @@ "docs-nav-proof-of-stake": "Proof of Stake", "docs-nav-proof-of-work": "Proof of Work", "page-upgrades-get-involved-ethresearch-1": "Sharding", - "page-upgrades-get-involved-ethresearch-2": "La Fusione" + "page-upgrades-get-involved-ethresearch-2": "La fusione" } diff --git a/src/intl/it/page-upgrades-vision.json b/src/intl/it/page-upgrades-vision.json new file mode 100644 index 00000000000..66f325e71bc --- /dev/null +++ b/src/intl/it/page-upgrades-vision.json @@ -0,0 +1,67 @@ +{ + "page-roadmap-vision-2014": "Leggi un post del blog del 2014 sulla proof of stake", + "page-roadmap-vision-2021": "Visualizza un post del blog del 2021 sull'evoluzione della tabella di marcia di Ethereum", + "page-roadmap-vision-2022": "Visualizza un post del blog del 2022: Guida per autostoppisti a Ethereum", + "page-roadmap-vision-2021-updates": "Visualizza un post del blog del 2021 sugli aggiornamenti del protocollo di Ethereum", + "page-roadmap-vision-desc-1": "Ethereum deve ridurre la congestione della rete e aumentare la velocità per servire meglio una base di utenti globale.", + "page-roadmap-vision-desc-2": "L'esecuzione di un nodo diventa sempre più difficile man mano che la rete cresce. E diventerà ancora più difficile con il lavoro svolto per ampliare la rete.", + "page-roadmap-vision-desc-3": "Ethereum utilizza troppa energia elettrica. La tecnologia che mantiene la rete sicura deve essere più sostenibile.", + "page-roadmap-vision-ethereum-node": "Maggiori informazioni sui nodi", + "page-roadmap-vision-future": "Un futuro digitale su scala globale", + "page-roadmap-vision-meta-desc": "Una panoramica dell'impatto che gli aggiornamenti avranno su Ethereum e le sfide che dovranno affrontare.", + "page-roadmap-vision-meta-title": "Visione di Ethereum", + "page-roadmap-vision-mining": "Maggiori informazioni sul mining", + "page-roadmap-vision-problems": "Problemi odierni", + "page-roadmap-vision-scalability": "Scalabilità", + "page-roadmap-vision-scalability-desc": "Ethereum deve essere in grado di gestire una maggiore quantità di transazioni per secondo senza aumentare la dimensione dei nodi nella rete. I nodi sono elementi essenziali della rete, archiviano ed eseguono la blockchain. Aumentare la dimensione dei nodi non è una soluzione pratica perché solo chi dispone di computer costosi e potenti potrebbe farlo.\nPer ampliarsi, Ethereum ha bisogno di gestire un numero maggiore di transazioni al secondo, abbinate a più nodi. Più nodi significa più sicurezza.", + "page-roadmap-vision-scalability-desc-3": "I rollup di livello 2 ampliano Ethereum spostando le transazioni off-chain e pubblicando esclusivamente dati di riepilogo su Ethereum. Questo raggruppamento aumenta il volume di Ethereum, riducendo drasticamente i costi per gli utenti.", + "page-roadmap-vision-scalability-desc-4": "I rollup necessitano di archiviazione a basso costo sul livello 1 per rendere le transazioni quanto più economiche possibili per gli utenti. Questa sarà fornita nella forma di blob, collegati ai blocchi di Ethereum. Infine, molti blob saranno collegati ai blocchi di Ethereum, fornendo archiviazione economica per molti rollup.", + "page-roadmap-vision-security": "Sicurezza", + "page-roadmap-vision-security-desc": "Gli aggiornamenti pianificati migliorano la sicurezza di Ethereum contro gli attacchi coordinati.", + "page-roadmap-vision-security-desc-3": "Nel proof of stake una maggiore sicurezza deriva da maggiori disincentivi cripto-economici agli attacchi. Questo perché, utilizzando il proof of stake, i validatori che proteggono la rete devono fare staking nel protocollo con importanti quantità di ETH. Se dovessero provare ad attaccare la rete, il protocollo potrebbe distruggere automaticamente i loro ETH.", + "page-roadmap-vision-security-desc-5": "Tuttavia, è anche importante che gli aggiornamenti che proteggono i validatori dagli attacchi denial-of-service, ne migliorino l'anonimato e che siano presto implementate la costruzione e la propagazione separate del blocco. Questi aggiornamenti proteggono i singoli validatori e l'intera rete dagli attacchi di vitalità e dalla censura.", + "page-roadmap-vision-security-desc-5-link": "Maggiori informazioni sul proof of stake", + "page-roadmap-vision-security-desc-10": "Staking significa anche che non è necessario investire in hardware d'élite per partecipare direttamente al consenso. Questo dovrebbe incoraggiare più utenti a diventare validatori, aumentando la decentralizzazione della rete e riducendo la superficie di attacco.", + "page-roadmap-vision-security-staking": "Fai staking con gli ETH", + "page-roadmap-vision-security-validator": "Puoi diventare validatore facendo staking con i tuoi ETH.", + "page-roadmap-vision-staking-lower": "Maggiori informazioni sullo staking", + "page-roadmap-vision-subtitle": "Far crescere Ethereum fino a che non sarà abbastanza potente per aiutare tutta l'umanità.", + "page-roadmap-vision-sustainability": "Sostenibilità", + "page-roadmap-vision-sustainability-desc-1": "Ethereum è ora una blockchain ecosostenibile. Il consumo energetico è stato ridotto di circa il 99,95% quando si è passati dal proof of work al proof of stake.", + "page-roadmap-vision-sustainability-desc-2": "Ethereum è ora protetta tramite lo staking, non dalla potenza di calcolo.", + "page-roadmap-vision-sustainability-desc-3": "Questo aumento della sostenibilità comporta anche benefici di sicurezza: l'ether in staking rende molto più costoso attaccare la catena rispetto alla modalità Proof of Work, ma rende meno costoso proteggerla poiché devono esser emessi meno nuovi ETH per pagare i validatori, rispetto ai miner.", + "page-roadmap-vision-sustainability-desc-8": "Il passaggio al Proof of Stake ha reso Ethereum più ecosostenibile e sicura. È una piattaforma a basse emissioni carboniche per creare app e organizzazioni.", + "page-roadmap-vision-sustainability-subtitle": "Ethereum è una blockchain ecosostenibile con una forte sicurezza cripto-economica.", + "page-roadmap-vision-title": "La visione di Ethereum", + "page-roadmap-vision-title-1": "Rete congestionata", + "page-roadmap-vision-title-2": "Spazio su disco", + "page-roadmap-vision-title-3": "Troppa energia", + "page-roadmap-vision-trilemma-cardtext-1": "Gli aggiornamenti di Ethereum lo renderanno scalabile, sicuro e decentralizzato. Lo staking ha abbassato la barriera della partecipazione e limitato le economie di scala, creando una rete più grande e più decentralizzata.", + "page-roadmap-vision-trilemma-cardtext-2": "Le reti blockchain sicure e decentralizzate richiedono che ogni nodo verifichi tutte le transazioni elaborate dalla catena. Questa mole di lavoro limita il numero di transazioni che possono essere effettuate in un dato momento. Decentralizzazione e sicurezza corrispondono a quello che è oggi la blockchain di Ethereum.", + "page-roadmap-vision-trilemma-cardtext-3": "Le reti decentralizzate funzionano inviando informazioni sulle transazioni attraverso i nodi: tutta la rete deve essere a conoscenza di ogni cambiamento di stato. Ampliare il numero di transazioni al secondo in una rete decentralizzata crea rischi di sicurezza perché più sono le transazioni, più aumenta il ritardo, più alta sarà la probabilità di un attacco perpetuato mentre le informazioni si spostano.", + "page-roadmap-vision-trilemma-cardtext-4": "Aumentare le dimensioni e la potenza dei nodi di Ethereum potrebbe aumentare le transazioni al secondo in modo sicuro, ma il requisito hardware limiterebbe chi potrebbe farlo e questo minaccia la decentralizzazione. Si spera che lo sharding e la proof-of-stake permetteranno a Ethereum di scalare aumentando la quantità di nodi, non la dimensione del nodo.", + "page-roadmap-vision-trilemma-h2": "La sfida dell'ampliamento decentralizzato", + "page-roadmap-vision-trilemma-modal-tip": "Tocca i cerchi qua sotto per capire meglio i problemi legati a un ampliamento decentralizzato", + "page-roadmap-vision-trilemma-p": "Un modo semplice per risolvere i problemi di Ethereum sarebbe quello di renderlo più centralizzato, ma la decentralizzazione è troppo importante. Essa dà ad Ethereum neutralità, resistenza alla censura, apertura, privacy e sicurezza dei dati quasi indistruttibile.", + "page-roadmap-vision-trilemma-p-1": "La visione di Ethereum è quella di essere più scalabile e sicura, ma anche di rimanere decentralizzata. Raggiungere queste 3 qualità è un problema noto come la trilemma della scalabilità.", + "page-roadmap-vision-trilemma-p-2": "Gli aggiornamenti di Ethereum mirano a risolvere il trilemma, ma ci sono sfide significative.", + "page-roadmap-vision-trilemma-press-button": "Scegli i pulsanti sul triangolo per capire meglio i problemi legati alla scalabilità decentralizzata.", + "page-roadmap-vision-trilemma-text-1": "Decentralizzazione", + "page-roadmap-vision-trilemma-text-2": "Sicurezza", + "page-roadmap-vision-trilemma-text-3": "Scalabilità", + "page-roadmap-vision-trilemma-title-1": "Esplora il trilemma della scalabilità", + "page-roadmap-vision-trilemma-title-2": "Aggiornamenti Ethereum e la scalabilità decentralizzata", + "page-roadmap-vision-trilemma-title-3": "Sicura e decentralizzata", + "page-roadmap-vision-trilemma-title-4": "Decentralizzata e scalabile", + "page-roadmap-vision-trilemma-title-5": "Scalabile e sicura", + "page-roadmap-vision-understanding": "Comprendere la visione di Ethereum", + "page-roadmap-vision-upgrade-needs": "La necessità degli aggiornamenti", + "page-roadmap-vision-upgrade-needs-desc": "Il protocollo Ethereum lanciato nel 2015 ha avuto un incredibile successo. La community di Ethereum però ha sempre saputo che sarebbero stati necessari alcuni aggiornamenti chiave per sbloccare il pieno potenziale di Ethereum.", + "page-roadmap-vision-upgrade-needs-desc-2": "La domanda elevata sta facendo aumentare le commissioni sulle transazioni, rendendo Ethereum costosa per l'utente medio. Lo spazio su disco necessario per eseguire un client Ethereum sta crescendo rapidamente. Inoltre, l'algoritmo di consenso Proof of Work che mantiene Ethereum sicura e decentralizzata ha un forte impatto ambientale.", + "page-roadmap-vision-upgrade-needs-desc-3": "Ethereum ha una serie di aggiornamenti che affrontano questi problemi e altri ancora. Questo set di aggiornamenti è stato originariamente chiamato 'Serenity' e 'Eth2,' e sono un'area attiva di ricerca e sviluppo dal 2014.", + "page-roadmap-vision-upgrade-needs-desc-5": "Ora che la tecnologia è pronta, questi aggiornamenti ri-progettano Ethereum per renderlo più scalabile, sicuro e sostenibile; per rendere la vita migliore per gli utenti esistenti e coinvolgerne di nuovi. Tutto preservando il valore centrale di Ethereum della decentralizzazione.", + "page-roadmap-vision-upgrade-needs-desc-6": "Questo significa che non ci sarà un interruttore per la scalabilità. I miglioramenti arriveranno incrementalmente con il tempo.", + "page-roadmap-vision-upgrade-needs-serenity": "Leggi un post del 2015 a proposito di \"Serenity\"", + "ethereum": "Ethereum", + "page-roadmap-vision-danksharding": "Di più sul Danksharding" +} diff --git a/src/intl/it/page-upgrades.json b/src/intl/it/page-upgrades.json index a9f47124ef5..21f9a8f82df 100644 --- a/src/intl/it/page-upgrades.json +++ b/src/intl/it/page-upgrades.json @@ -4,12 +4,13 @@ "page-upgrades-beacon-date": "Spedita!", "page-upgrades-merge-date": "Settembre 2022", "page-upgrades-shards-date": "~2023", + "page-upgrades-pbs": "Non imminente, previsto 2024/25", "page-upgrades-post-merge-banner-tutorial-ood": "Questo tutorial è deprecato dopo La Fusione e potrebbe non funzionare. Sei pregato di effettuare una PR se vorresti contribuire.", "page-upgrades-post-merge-banner-governance-ood": "Alcuni contenuti su questa pagina sono obsoleti dopo La Fusione. Sei pregato di effettuare una PR, se vorresti contribuire.", "page-upgrades-upgrades-guide": "Guida agli aggiornamenti di Ethereum", "page-upgrades-upgrades-docking": "La fusione", "page-upgrades-shard-title": "Sharding", - "page-upgrades-upgrades-beacon-chain": "La Cadena de Baliza", + "page-upgrades-upgrades-beacon-chain": "La beacon chain", "consensus-beaconcha-in-desc": "Piattaforma di ricerca Beacon Chain open source", "consensus-beaconscan-desc": "Piattaforma di ricerca Beacon Chain - Etherscan per il livello di consenso", "consensus-become-staker": "Diventa uno staker", @@ -17,5 +18,5 @@ "consensus-explore": "Esplora i dati", "consensus-run-beacon-chain": "Esegui un client di consenso", "consensus-run-beacon-chain-desc": "Ethereum ha bisogno del maggior numero possibile di client in esecuzione. Contribuisci con questo bene pubblico di Ethereum!", - "read-more": "Ulteriori contenuti" + "read-more": "Leggi altro" } diff --git a/src/intl/it/page-wallets-find-wallet.json b/src/intl/it/page-wallets-find-wallet.json index 5d6a89f1303..a00a30f5773 100644 --- a/src/intl/it/page-wallets-find-wallet.json +++ b/src/intl/it/page-wallets-find-wallet.json @@ -1,59 +1,59 @@ { - "page-find-wallet-clear": "Cancella filtri", - "page-find-wallet-desc-2": "Quindi, scegli il tuo portafoglio in base alle caratteristiche che desideri.", - "page-find-wallet-description": "I portafogli hanno moltissime funzionalità opzionali che potrebbero piacerti.", + "page-find-wallet-clear": "Cancella i filtri", + "page-find-wallet-desc-2": "Quindi, scegli il tuo portafoglio a seconda delle funzionalità che desideri.", + "page-find-wallet-description": "I portafogli hanno moltissime funzionalità facoltative, che potrebbero piacerti.", "page-find-wallet-last-updated": "Ultimo aggiornamento", - "page-find-wallet-meta-description": "Trova e confronta portafogli Ethereum in base alle caratteristiche che cerchi.", - "page-find-wallet-meta-title": "Trova un portafoglio Ethereum", + "page-find-wallet-meta-description": "Trova e confronta i portafogli di Ethereum, a seconda delle funzionalità che desideri.", + "page-find-wallet-meta-title": "Trova un portafoglio di Ethereum", "page-find-wallet-title": "Trova un portafoglio", - "page-find-wallet-try-removing": "Prova rimuovere una o due funzionalità", + "page-find-wallet-try-removing": "Prova a rimuovere una o due funzionalità", "page-find-wallet-choose-to-compare": "Seleziona per confrontare", - "page-stake-eth": "Fai staking con gli ETH", + "page-stake-eth": "Metti ETH in Staking", "page-find-wallet-open-source": "Open source", - "page-find-wallet-open-source-desc": "Software open source che consente a chiunque di controllare l'integrità e la sicurezza dell'applicazione", + "page-find-wallet-open-source-desc": "Software open source che consente a chiunque di verificare l'integrità e la sicurezza dell'applicazione", "page-find-wallet-self-custody": "Custodia autonoma", - "page-find-wallet-non-custodial": "Non custodial", - "page-find-wallet-non-custodial-desc": "Portafogli che non controllano le tue chiavi private", - "page-find-wallet-hardware-wallet-support": "Supporto portafogli hardware", - "page-find-wallet-hardware-wallet-support-desc": "Portafogli che possono connettersi a portafogli hardware per una migliore sicurezza", + "page-find-wallet-non-custodial": "Privo di custodia", + "page-find-wallet-non-custodial-desc": "I portafogli che non controllano le tue chiavi private", + "page-find-wallet-hardware-wallet-support": "Supporto portafoglio hardware", + "page-find-wallet-hardware-wallet-support-desc": "Portafogli che possono connettersi a portafogli hardware, per una migliore sicurezza", "page-find-wallet-walletconnect": "WalletConnect", - "page-find-wallet-walletconnect-desc": "Portafogli che supportano WalletConnect per connettersi a dapp", + "page-find-wallet-walletconnect-desc": "Portafogli che supportano WalletConnect per la connessione alle dapp", "page-find-wallet-rpc-importing": "Importazione RPC", - "page-find-wallet-rpc-importing-desc": "Portafogli che supportano endpoint RPC personalizzati per connettersi a nodi o reti differenti", + "page-find-wallet-rpc-importing-desc": "Portafogli che supportano gli endpoint RPC personalizzati, per connettersi a nodi o reti differenti", "page-find-wallet-nft-support": "Supporto NFT", "page-find-wallet-nft-support-desc": "Portafogli che supportano la visualizzazione e l'interazione con i tuoi NFT", - "page-find-wallet-connect-to-dapps": "Connessione a dapp", - "page-find-wallet-connect-to-dapps-desc": "Portafogli che si connettono ad applicazioni create sulla rete di Ethereum", + "page-find-wallet-connect-to-dapps": "Connessione alle dapp", + "page-find-wallet-connect-to-dapps-desc": "Portafogli che si connettono ad applicazioni basate sulla rete di Ethereum", "page-find-wallet-staking": "Staking", - "page-find-wallet-staking-desc": "Metti ETH in staking direttamente dal portafoglio", + "page-find-wallet-staking-desc": "Metti ETH in staking, direttamente dal portafoglio", "page-find-wallet-swaps": "Scambi", "page-find-wallet-swaps-desc": "Scambia token ERC-20 direttamente nel portafoglio", "page-find-wallet-layer-2": "Livello 2", "page-find-wallet-layer-2-desc": "Portafogli che supportano i livelli 2 di Ethereum", - "page-find-wallet-gas-fee-customization": "Personalizzazione commissione di gas", - "page-find-wallet-gas-fee-customization-desc": "Personalizza i tuoi importi di gas (commissione di base, commissione prioritaria e commissione massima)", + "page-find-wallet-gas-fee-customization": "Personalizzazione della commissione sul gas", + "page-find-wallet-gas-fee-customization-desc": "Personalizza i tuoi importi di gas (commissione di base, prioritaria e massima)", "page-find-wallet-ens-support": "Supporto ENS", - "page-find-wallet-ens-support-desc": "Portafogli che supportano l’Ethereum Name Service (ENS)", - "page-find-wallet-token-importing": "Importazione token", + "page-find-wallet-ens-support-desc": "Portafogli che supportano il Servizio del Nome di Ethereum (ENS)", + "page-find-wallet-token-importing": "Importazione dei token", "page-find-wallet-token-importing-desc": "Importa qualsiasi token ERC-20 da usare nel portafoglio", "page-find-wallet-fee-optimization": "Ottimizzazione delle commissioni", - "page-find-wallet-fee-optimization-desc": "Supporta transazioni di tipo 2 per commissioni di gas ottimizzate e rimborsi di commissioni per il gas inutilizzato", + "page-find-wallet-fee-optimization-desc": "Supporta le transazioni di tipo 2 per le commissioni sul gas ottimizzate e i rimborsi di commissioni per il gas inutilizzato", "page-find-wallet-buy-crypto": "Acquista criptovalute", - "page-find-wallet-buy-crypto-desc": "Acquista criptovalute con valute legali direttamente nel portafoglio\n*Nota: l'acquisto di criptovalute potrebbe variare da regione a regione", + "page-find-wallet-buy-crypto-desc": "Acquista criptovalute con valute legali, direttamente nel portafoglio \n *Nota: l'acquisto di criptovalute potrebbe essere specifico per regione", "page-find-wallet-sell-for-fiat": "Vendi per valuta legale", - "page-find-wallet-sell-for-fiat-desc": "Vendi criptovalute per valute legali direttamente nel portafoglio\n*Nota: il prelievo di criptovalute potrebbe variare da regione a regione", + "page-find-wallet-sell-for-fiat-desc": "Vendi criptovalute per valute legali, direttamente nel portafoglio \n *Nota: il prelievo di criptovalute potrebbe essere specifico per regione", "page-find-wallet-multisig": "Firma Multipla", "page-find-wallet-multisig-desc": "Portafogli che richiedono firme multiple per autorizzare una transazione", - "page-find-wallet-social-recovery": "Recupero social", - "page-find-wallet-social-recovery-desc": "Portafogli che consentono ai guardiani di modificare la chiave di firma per i portafogli di contratti intelligenti", - "page-find-wallet-token-support": "Supporto token", + "page-find-wallet-social-recovery": "Recupero sociale", + "page-find-wallet-social-recovery-desc": "Portafogli che consentono ai tutori di modificare la chiave di firma per i portafogli di contratti intelligenti", + "page-find-wallet-token-support": "Supporto ai token", "page-find-wallet-features": "Caratteristiche", "page-find-wallet-security": "Sicurezza", "page-find-wallet-smart-contract": "Smart Contract", "page-find-wallet-check-out": "Dai un'occhiata a:", "page-find-wallet-info-updated-on": "info aggiornate il", "page-find-wallet-showing-all-wallets": "Mostra tutti i portafogli", - "page-find-wallet-showing": "Vengono mostrati ", + "page-find-wallet-showing": "Mostrando", "page-find-wallet-wallets": "portafogli", "page-find-wallet-iOS": "iOS", "page-find-wallet-android": "Android", @@ -64,29 +64,31 @@ "page-find-wallet-firefox": "Firefox", "page-find-wallet-hardware": "Hardware", "page-find-wallet-hardware-desc": "Portafogli hardware", - "page-find-wallet-new-to-crypto-title": "Senza conoscenza di criptovalute", - "page-find-wallet-new-to-crypto-desc": "Sei un utente alla ricerca del suo primo portafoglio", + "page-find-wallet-new-to-crypto-title": "Nuovo alle criptovalute", + "page-find-wallet-new-to-crypto-desc": "Sei un utente alle prime armi, alla ricerca del primo portafoglio", "page-find-wallet-nfts-title": "NFT", - "page-find-wallet-nfts-desc": "Sei un utente che sa già tutto sugli NFT e cerca un portafoglio con supporto agli NFT", + "page-find-wallet-nfts-desc": "Sei un utente che sa già tutto sui NFT e desidera un portafoglio che li supporti", "page-find-wallet-hodler-title": "Hodler", "page-find-wallet-hodler-desc": "Sei un utente che possiede dei token e non desidera toccarli", "page-find-wallet-finance-title": "Finanza", - "page-find-wallet-finance-desc": "Sei un utente che utilizza DeFi e desideri un portafoglio che ti consenta di connetterti alle applicazioni di DeFi", + "page-find-wallet-finance-desc": "Sei un utente che utilizza la DeFi e desidera un portafoglio che consenta di connettersi alle applicazioni di DeFi", "page-find-wallet-developer-title": "Sviluppatore", "page-find-wallet-developer-desc": "Sei uno sviluppatore e necessiti di un portafoglio che ti aiuti a sviluppare e testare dapp", - "page-find-wallet-persona-desc": "Scegli il profilo che corrisponde al tuo tipo di utente e filtra l'elenco di portafogli", + "page-find-wallet-persona-desc": "Scegli il profilo corrispondente al tuo tipo di utente e filtra l'elenco di portafogli", "page-find-wallet-filters": "Filtri", "page-find-wallet-active": "attivi", "page-find-wallet-profile-filters": "Filtri del profilo", - "page-find-wallet-feature-filters": "Filtri di funzionalità", - "page-find-wallet-footnote-1": "I portafogli elencati su questa pagina non sono sponsorizzazioni ufficiali e sono messi a disposizione per soli scopi informativi.", + "page-find-wallet-feature-filters": "Filtri delle funzionalità", + "page-find-wallet-footnote-1": "I portafogli elencati su questa pagina non sono sponsorizzazioni ufficiali, e sono forniti a solo scopo informativo.", "page-find-wallet-footnote-2": "Le loro descrizioni sono state fornite dagli stessi progetti dei portafogli.", - "page-find-wallet-footnote-3": "Aggiungiamo prodotti a questa pagina secondo i criteri nella nostra politica di elencazione. Se vorresti che aggiungessimo un portafoglio, apri un ticket su GitHub.", + "page-find-wallet-footnote-3": "Aggiungiamo prodotti a questa pagina secondo i criteeri nella nostra politica di inserzione. Se vorresti che aggiungessimo un portafoglio, apri un ticket su GitHub.", "page-find-wallet-mobile": "Mobile", "page-find-wallet-mobile-desc": "Portafogli con app mobili", "page-find-wallet-desktop": "Desktop", "page-find-wallet-desktop-desc": "Portafogli con app desktop", "page-find-wallet-browser": "Browser", "page-find-wallet-browser-desc": "Portafogli con estensioni per browser", - "page-find-wallet-device": "Dispositivo" + "page-find-wallet-device": "Dispositivo", + "page-find-choose-to-compare": "Seleziona per confrontare", + "page-find-wallet-choose-features": "Scegli le funzionalità" } diff --git a/src/intl/it/page-wallets.json b/src/intl/it/page-wallets.json index f4c728c716a..a118bc703f8 100644 --- a/src/intl/it/page-wallets.json +++ b/src/intl/it/page-wallets.json @@ -1,65 +1,67 @@ { "page-wallets-accounts-addresses": "Portafogli, conti e indirizzi", "page-wallets-accounts-addresses-desc": "Vale la pena di comprendere le differenze tra alcuni termini chiave.", - "page-wallets-accounts-ethereum-addresses": "Un conto Ethereum ha un indirizzo di Ethereum, come una casella di posta ha un indirizzo email. Puoi usarlo per inviare fondi a un conto.", - "page-wallets-alt": "Figura di un robot con una cassaforte come corpo che rappresenta un portafoglio Ethereum", + "page-wallets-accounts-ethereum-addresses": "Un conto di Ethereum ha un indirizzo di Ethereum, come una casella ha un indirizzo email. Puoi utilizzarlo per inviare fondi a un conto.", + "page-wallets-alt": "Figura di un robot con una cassaforte come corpo, rappresentante un portafoglio di Ethereum", "page-wallets-ethereum-account": "Un conto di Ethereum è un'entità che può inviare transazioni e ha un saldo.", "page-wallets-blog": "Blog di Coinbase", "page-wallets-bookmarking": "Salva il tuo portafoglio tra i preferiti", - "page-wallets-bookmarking-desc": "Se usi un portafoglio web, mettere il sito tra i preferiti ti aiuta a proteggerti da truffe e phishing.", - "page-wallets-cd": "I portafogli hardware fisici sono dispositivi che consentono di conservare le criptovalute offline - molto sicuri", - "page-wallets-desc-2": "Serve un portafoglio per inviare fondi e gestire i tuoi ETH.", - "page-wallets-desc-2-link": "Scopri di più su ETH", - "page-wallets-desc-3": "Il tuo portafoglio è solo uno strumento per gestire il tuo conto di Ethereum. Ciò significa che puoi cambiare fornitore del portafoglio in qualsiasi momento. Molti portafogli, inoltre, ti consentono di gestire diversi conti di Ethereum da un'applicazione.", - "page-wallets-desc-4": "Questo perché non hanno custodia dei tuoi fondi, quella spetta a te. I portafogli sono solo uno strumento per gestire quello che è tuo.", - "page-wallets-description": "I portafogli di Ethereum sono applicazioni che ti consentono di interagire con il tuo conto di Ethereum. Immaginali come un'app bancaria su internet, senza la banca. Il tuo portafoglio ti consente di leggere il tuo saldo, inviare transazioni e connetterti alle applicazioni.", - "page-wallets-desktop": "Applicazioni desktop, se preferisci gestire i tuoi fondi via macOS, Windows o Linux", - "page-wallets-ethereum-wallet": "Un portafoglio è un prodotto che ti consente di gestire il tuo conto di Ethereum. Ti consente di visualizzare ils aldo del tuo conto, inviare transazioni e altro.", + "page-wallets-bookmarking-desc": "Se utilizzi un portafoglio web, mettere il sito tra i preferiti ti aiuta a proteggerti da truffe e phishing.", + "page-wallets-cd": "I portafogli hardware fisici sono dispositivi che consentono di conservare le criptovalute offline e sono molto sicuri", + "page-wallets-desc-2": "Necessiti di un portafoglio per inviare fondi e gestire i tuoi ETH.", + "page-wallets-desc-2-link": "Di più su ETH", + "page-wallets-desc-3": "Il tuo portafoglio è soltanto uno strumento per gestire il tuo conto di Ethereum. Ciò significa che puoi cambiare fornitore del portafoglio in qualsiasi momeento. Inoltre, molti portafogli ti consentono di gestire svariati conti di Ethereum, da una singola applicazione.", + "page-wallets-desc-4": "Questo perché i portafogli non hanno custodia dei tuoi fondi, tu sì. Sono semplicemente strumenti per gestire ciò che possiedi.", + "page-wallets-description": "I portafogli di Ethereum sono applicazioni che ti consentono di interagire con il tuo conto di Ethereum. Immaginali come un'app bancaria su Internet, senza la banca. Il tuo portafoglio ti consente di leggere il tuo saldo, inviare transazioni e connetterti alle applicazioni.", + "page-wallets-desktop": "Applicazioni desktop, se preferisci gestire i tuoi fondi su macOS, Windows o Linux", + "page-wallets-ethereum-wallet": "Un portafoglio è un prodotto che ti consente di gestire il tuo conto di Ethereum. Ti consente di visualizzare il saldo del tuo conto, inviare transazioni e altro.", "page-wallets-explore": "Esplora Ethereum", - "page-wallets-features-desc": "Possiamo aiutarti a scegliere il tuo portafoglio in base alle caratteristiche che ti interessano.", - "page-wallets-features-title": "Confronta i portafogli in base alle funzionalità", + "page-wallets-features-desc": "Possiamo aiutarti a scegliere il tuo portafoglio, a seconda delle funzionalità che ti interessano.", + "page-wallets-features-title": "Confronta i portafogli a seconda delle funzionalità", "page-wallets-find-wallet-btn": "Trova un portafoglio", "page-wallets-find-wallet-link": "Trova un portafoglio", - "page-wallets-get-some": "Ottieni ETH", + "page-wallets-get-some": "Ottieni degli ETH", "page-wallets-get-some-alt": "Figura di una mano che crea il logo ETH con mattoncini Lego", "page-wallets-get-some-btn": "Ottieni ETH", - "page-wallets-get-some-desc": "ETH è la criptovaluta nativa di Ethereum. Ti serviranno alcuni ETH nel tuo portafoglio per utilizzare le applicazioni di Ethereum.", - "page-wallets-how-to-store": "Come conservare risorse digitali su Ethereum", - "page-wallets-keys-to-safety": "I segreti per tenere al sicuro le tue criptovalute", + "page-wallets-get-some-desc": "Gli ETH sono la criptovaluta nativa di Ethereum. Necessiterai di degli ETH nel tuo portafoglio, per utilizzare le applicazioni di Ethereum.", + "page-wallets-how-to-store": "Come conservare le risorse digitali su Ethereum", + "page-wallets-keys-to-safety": "I segreti per mantenere le tue criptovalute al sicuro", "page-wallets-manage-funds": "Un'app per gestire i tuoi fondi", - "page-wallets-manage-funds-desc": "Il tuo portafoglio mostra il tuo saldo, la cronologia delle transazioni e ti offre la possibilità di inviare o ricevere fondi. Alcuni portafogli possono offrire funzioni aggiuntive.", - "page-wallets-meta-description": "Cosa devi sapere per utilizzare portafogli Ethereum.", - "page-wallets-meta-title": "Portafogli Ethereum", + "page-wallets-manage-funds-desc": "Il tuo portafoglio mostra il tuo saldo, lo storico delle transazioni e ti offre la possibilità di inviare e ricevere fondi. Alcuni portafogli potrebbero offrire dell'altro.", + "page-wallets-meta-description": "Cosa devi sapere per utilizzare i portafogli di Ethereum.", + "page-wallets-meta-title": "Portafogli di Ethereum", "page-wallets-mobile": "Applicazioni mobili che rendono i tuoi fondi accessibili ovunque", - "page-wallets-more-on-dapps-btn": "Maggiori informazioni sulle dapp", + "page-wallets-more-on-dapps-btn": "Di più sulle dapp", "page-wallets-most-wallets": "Gran parte dei portafogli ti consentiranno di generare un conto di Ethereum. Quindi, non ne necessiti uno, prima di scaricare un portafoglio.", "page-wallets-protecting-yourself": "Proteggi te e i tuoi fondi", - "page-wallets-seed-phrase": "Prendi nota della tua seed phrase", - "page-wallets-seed-phrase-desc": "I portafogli spesso ti forniscono una seed phrase che devi scrivere e conservare in un luogo sicuro. Sarà l'unico modo per recuperare il tuo portafoglio.", + "page-wallets-seed-phrase": "Annota la tua frase di seed", + "page-wallets-seed-phrase-desc": "Spesso, i portafogli, ti forniranno una frase di seed che devi annotare al sicuro. Questo è il solo modo per poter recuperare il tuo portafoglio.", "page-wallets-seed-phrase-example": "Ecco un esempio:", "page-wallets-seed-phrase-snippet": "there aeroplane curve vent formation doge possible product distinct under spirit lamp", - "page-wallets-seed-phrase-write-down": "Non salvarla su un computer. Scrivila a penna da qualche parte e tienila al sicuro.", + "page-wallets-seed-phrase-write-down": "Non salvarla su un computer. Annotala e tienila al sicuro.", "page-wallets-slogan": "La chiave per il tuo futuro digitale", "page-wallets-stay-safe": "Come rimanere al sicuro", - "page-wallets-stay-safe-desc": "I portafogli richiedono un piccolo sforzo mentale. La libertà finanziaria e la possibilità di accedere ai propri fondi e utilizzarli ovunque è legata a un po' di responsabilità. Non esiste il supporto clienti per le criptovalute.", - "page-wallets-subtitle": "I portafogli ti danno accesso ai tuoi fondi e alle applicazioni Ethereum. Solo tu dovresti avere accesso al tuo portafoglio.", - "page-wallets-take-responsibility": "Prenditi la responsabilità dei tuoi fondi", - "page-wallets-take-responsibility-desc": "Le borse centralizzate collegano il tuo portafoglio a uno username e una password che puoi recuperare in maniera tradizionale. Ricordati solo che ti stai fidando della borsa affidando i tuoi fondi in custodia. Se l'azienda dovesse venire attaccata o fallire, i tuoi fondi potrebbero essere a rischio.", - "page-wallets-tips": "Altri consigli su come mantenere la sicurezza", + "page-wallets-stay-safe-desc": "I portafogli richiedono una mentalità un po' differente, per quanto riguarda la sicurezza. La libertà finanziaria e la capacità di accedere ai fondi e utilizzarli ovunque, richiede un po' di responsabilità: non esiste il supporto clienti per le criptovalute.", + "page-wallets-subtitle": "I portafogli danno accesso ai tuoi fondi e alle applicazioni di Ethereum. Soltanto tu dovresti avere accesso al tuo portafoglio.", + "page-wallets-take-responsibility": "Assumiti le responsabilità suoi tuoi fondi", + "page-wallets-take-responsibility-desc": "Le piattaforme di scambio centralizzate collegheranno il tuo portafoglio a un nome utente e una password, recuperabili con il metodo tradizionale. Basta ricordarsi che si sta affidando a tale piattaforma la custodia sui propri fondi. Se tale azienda viene attaccata o fallisce, i tuoi fondi saranno a rischio.", + "page-wallets-tips": "Di più sul restare al sicuro", "page-wallets-tips-community": "Dalla community", "page-wallets-title": "Portafogli Ethereum", "page-wallets-triple-check": "Fai un triplo controllo su tutto", - "page-wallets-triple-check-desc": "Ricordati che le transazioni non sono reversibili e che i portafogli non sono facilmente recuperabili, quindi prendi le dovute precauzioni e presta sempre attenzione.", + "page-wallets-triple-check-desc": "Ricordati che le transazioni sono irreversibili e che i portafogli non sono facilmente recuperabili, quindi, prendi le dovute precauzioni e presta sempre attenzione.", "page-wallets-try-dapps": "Prova alcune dapp", "page-wallets-try-dapps-alt": "Figura dei membri della community Ethereum che lavorano insieme", - "page-wallets-try-dapps-desc": "Le dapp sono applicazioni costruite su Ethereum. Sono più economiche, eque e attente ai tuoi dati rispetto alla maggior parte delle applicazioni tradizionali.", + "page-wallets-try-dapps-desc": "Le dapp sono applicazioni basate su Ethereum. Sono più economiche, eque e attente ai tuoi dati, di gran parte delle applicazioni tradizionali.", "page-wallets-types": "Tipi di portafogli", - "page-wallets-types-desc": "Esistono alcuni modi per interfacciarsi e interagire con il tuo conto:", - "page-wallets-web-browser": "I portafogli del browser sono applicazioni web che ti consentono di interagire con il tuo conto direttamente nel browser", - "page-wallets-web-browser-extension": "I portafogli browser sono estensioni che scarichi e ti consentono di interagire con il tuo conto e le applicazioni tramite il browser", - "page-wallets-whats-a-wallet": "Cos'è un portafoglio Ethereum?", + "page-wallets-types-desc": "Esistono alcuni modi per interfacciarsi a e interagire con il tuo conto:", + "page-wallets-web-browser": "I portafogli su browser sono applicazioni che ti consentono di interagire con il tuo conto, direttamente sul browser", + "page-wallets-web-browser-extension": "I portafogli per browser sono estensioni scaricabili, che ti consentono di interagire con il tuo conto e con le applicazioni, tramite il browser", + "page-wallets-whats-a-wallet": "Cos'è un portafoglio di Ethereum?", "page-wallets-your-ethereum-account": "Il tuo conto di Ethereum", - "page-wallets-your-ethereum-account-desc": "Il tuo portafoglio è la tua finestra al tuo conto di Ethereum: il tuo saldo, lo storico delle transazioni e altro. Ma puoi cambiare fornitore dele portafoglio in qualsiasi momento.", - "page-wallets-your-login": "Il tuo login per le applicazioni Ethereum", - "page-wallets-your-login-desc": "Il tuo portafoglio ti consente di connetterti a qualsiasi applicazioni decentralizzata usando il tuo conto di Ethereum. È come un login, utilizzabile su molte dapp." + "page-wallets-your-ethereum-account-desc": "Il tuo portafoglio è la finestra al tuo conto di Ethereum: il tuo saldo, lo storico delle transazioni e altro. Ma puoi cambiare fornitore in qualsiasi momento.", + "page-wallets-your-login": "Il tuo accesso alle applicazioni di Ethereum", + "page-wallets-your-login-desc": "Il tuo portafoglio consente di connetterti a qualsiasi applicazione decentralizzata, utilizzando il tuo conto di Ethereum. È come un accesso, utilizzabile su svariate dapp.", + "additional-reading-how-to-register-an-ethereum-account": "Come \"registrare\" un conto di Ethereum", + "additional-reading-how-to-use-a-wallet": "Come utilizzare un portafoglio" } diff --git a/src/intl/it/page-what-is-ethereum.json b/src/intl/it/page-what-is-ethereum.json index 5e2d53e04b8..7059df032ef 100644 --- a/src/intl/it/page-what-is-ethereum.json +++ b/src/intl/it/page-what-is-ethereum.json @@ -1,117 +1,117 @@ { - "page-what-is-ethereum-alt-img-bazaar": "Figura di una persona che sbircia in un bazar, che rappresenta Ethereum", - "page-what-is-ethereum-alt-img-comm": "Figura dei membri della community di Ethereum che lavorano insieme", - "page-what-is-ethereum-alt-img-lego": "Figura di una mano che crea il logo ETH formato da mattoncini di Lego", + "page-what-is-ethereum-alt-img-bazaar": "Illustrazione di una persona che scruta in un bazaar, a rappresentare Ethereum", + "page-what-is-ethereum-alt-img-comm": "Un'illustrazione dei membri della community di Ethereum che collaborano", + "page-what-is-ethereum-alt-img-lego": "Un'illustrazione di una mano che crea un logo di ETH, composto da mattoncini Lego", "page-what-is-ethereum-banking-card": "Attività bancarie per tutti", - "page-what-is-ethereum-banking-card-desc": "Non tutti hanno accesso ai servizi finanziari. Tutto ciò che ti serve per accedere a Ethereum e al suo sistema di prestiti e prodotti di risparmio è una connessione internet.", - "page-what-is-ethereum-build": "Fai qualcosa con Ethereum", - "page-what-is-ethereum-build-desc": "Se vuoi provare a costruire con Ethereum, leggere i nostri documenti, provare alcuni tutorial o dare un'occhiata agli strumenti che ti servono per iniziare.", - "page-what-is-ethereum-censorless-card": "Anti-censura", - "page-what-is-ethereum-censorless-card-desc": "Nessun governo o azienda ha il controllo su Ethereum. Questa decentralizzazione rende praticamente impossibile per chiunque impedire di ricevere pagamenti o di utilizzare i servizi basati su Ethereum.", - "page-what-is-ethereum-comm-desc": "La nostra community include persone con ogni tipo di background, inclusi artisti, cripto-anarchici, aziende Fortune 500 e ora anche te. Scopri come poter partecipare fin da subito.", + "page-what-is-ethereum-banking-card-desc": "Non tutti hanno accesso ai servizi finanziari. Tutto ciò che ti serve per accedere a Ethereum e ai suoi servizi di assunzione ed erogazione di prestiti e prodotti di risparmio, è una connessione a Internet.", + "page-what-is-ethereum-build": "Crea qualcosa con Ethereum", + "page-what-is-ethereum-build-desc": "Se vuoi provare a creare con Ethereum, leggi la nostra documentazione, prova alcuni tutorial o consulta gli strumenti necessari per iniziare.", + "page-what-is-ethereum-censorless-card": "Resistente alla censura", + "page-what-is-ethereum-censorless-card-desc": "Nessun governo o azienda ha il controllo su Ethereum. Questa decentralizzazione, rende praticamente impossibile per chiunque, di impedirti di ricevere pagamenti o usufruire di servizi su Ethereum.", + "page-what-is-ethereum-comm-desc": "La nostra community include persone da tutti i contesti, inclusi artisti, cripto-anarchici, aziende di Fortune 500 e, adesso, anche tu. Scopri oggi come puoi partecipare.", "page-what-is-ethereum-commerce-card": "Garanzie commerciali", - "page-what-is-ethereum-commerce-card-desc": "I clienti hanno una garanzia sicura e integrata che i fondi saranno trasferiti se fornirete quanto concordato. Analogamente, gli sviluppatori possono avere la certezza che le regole non cambieranno per loro.", + "page-what-is-ethereum-commerce-card-desc": "I clienti hanno una garanzia sicura e integrata che i fondi cambieranno mani soltanto se forniranno quanto concordato. Analogamente, gli sviluppatori possono avere la certezza che le regole su di loro non cambieranno.", "page-what-is-ethereum-composable-card": "Tutti i prodotti sono componibili", - "page-what-is-ethereum-composable-card-desc": "Poiché tutte le app sono create sulla stessa blockchain con uno stato globale condiviso, possono costruirsi basandosi le une sulle altre (come i lego). Questo consente la costruzione di prodotti ed esperienze sempre migliori.", - "page-what-is-ethereum-community": "La community Ethereum", - "page-what-is-ethereum-desc": "La base per il nostro futuro digitale", + "page-what-is-ethereum-composable-card-desc": "Poiché tutte le app sono basate sulla stessa blockchain con uno stato globale condiviso, possono basarsi l'una sull'altra (come i Lego). Ciò consente la creazione di prodotti ed esperienze sempre migliori.", + "page-what-is-ethereum-community": "La community di Ethereum", + "page-what-is-ethereum-desc": "Le fondamenta per il nostro futuro digitale", "page-what-is-ethereum-explore": "Esplora Ethereum", - "page-what-is-ethereum-internet-card": "Un internet più privato", - "page-what-is-ethereum-internet-card-desc": "Non devi fornire tutte le tue informazioni personali per usare un'app Ethereum. Ethereum crea un'economia basata sul valore, non sulla sorveglianza.", + "page-what-is-ethereum-internet-card": "Un Internet più privato", + "page-what-is-ethereum-internet-card-desc": "Non devi fornire tutte le tue informazioni personali per utilizzare un'app di Ethereum. Ethereum sta creando un'economia basata sul valore, non sulla sorveglianza.", "page-what-is-ethereum-meet-comm": "Incontra la community", - "page-what-is-ethereum-meta-description": "Scopri di più su Ethereum, cosa fa e come puoi provarla.", + "page-what-is-ethereum-meta-description": "Impara su Ethereum, su cosa fa e come provarlo.", "page-what-is-ethereum-meta-title": "Cos'è Ethereum?", - "page-what-is-ethereum-p2p-card": "Una rete peer-to-peer", - "page-what-is-ethereum-p2p-card-desc": "Ethereum ti permette di spostare denaro, o stringere accordi, direttamente con altri. Non è necessario ricorrere a intermediari.", - "page-what-is-ethereum-start-building-btn": "Inizia a sviluppare", + "page-what-is-ethereum-p2p-card": "Una rete tra pari", + "page-what-is-ethereum-p2p-card-desc": "Ethereum ti consente di spostare denaro, o stringere accordi, direttamente con altri. Non devi ricorrere ad aziende intermediarie.", + "page-what-is-ethereum-start-building-btn": "Inizia a creare", "page-what-is-ethereum-title": "Cos'è Ethereum?", - "page-what-is-ethereum-subtitle": "Una guida completa per principianti a come funziona Ethereum, i benefici che comporta e come è usata da milioni di persone in tutto il mondo.", + "page-what-is-ethereum-subtitle": "Una guida per principianti completa al funzionamento di Ethereum, ai benefici che comporta e a come è utilizzato da milioni di persone in tutto il mondo.", "page-what-is-ethereum-button-lets-start": "Iniziamo", "page-what-is-ethereum-blockchain-tab-title": "Cos'è una blockchain?", - "page-what-is-ethereum-blockchain-tab-content": "Una blockchain è un database di transazioni che viene aggiornato e condiviso tra molti computer in una rete. Ogni volta viene aggiunta una nuova serie di transazioni, chiamata \"blocco\", da cui il nome blockchain. Gran parte delle blockchain sono pubbliche ed è possibile solo aggiungere dati, non rimuoverli. Se qualcuno volesse alterare alcune delle informazioni o truffare il sistema, dovrebbe farlo sulla maggioranza dei computer sulla rete. E sono molti! Questo rende le blockchain esistenti come Ethereum altamente sicure.", - "page-what-is-ethereum-cryptocurrency-tab-title": "Perché la chiamano criptovaluta?", - "page-what-is-ethereum-cryptocurrency-tab-content": "Le blockchain usano tecniche crittografiche per garantire che i tuoi fondi siano al sicuro. Tecniche simili sono usate da anni nel settore bancario per assicurare la sicurezza delle transazioni monetarie. Quindi si potrebbe dire che le criptovalute hanno un livello di sicurezza paragonabile a quello di una banca.", + "page-what-is-ethereum-blockchain-tab-content": "Una blockchain è un database di transazioni, aggiornato e condiviso tra molti computer in una rete. Ogni volta che è aggiunta una nuova serie di transazioni, questa è detta \"blocco\", da cui il nome, blockchain. Gran parte delle blockchain sono pubbliche, ed è soltanto possibile aggiungervi dati, non rimuoverli. Se qualcuno volesse alterare le informazioni o ingannare il sistema, dovrebbe farlo sulla maggioranza dei computer sulla rete. E sono molti! Ciò, rende le blockchain esistenti, come Ethereum, altamente sicure.", + "page-what-is-ethereum-cryptocurrency-tab-title": "Perché si chiamano criptovalute?", + "page-what-is-ethereum-cryptocurrency-tab-content": "Le blockchain utilizzano tecniche crittografiche per assicurarsi che i tuoi fondi siano al sicuro. Tecniche simili sono state utilizzate nelle industrie bancarie per assicurare la sicurezza delle transazioni monetarie, per anni. Quindi, potresti dire che le criptovalute hanno un livello di sicurezza bancario.", "page-what-is-ethereum-summary-title": "Riepilogo", - "page-what-is-ethereum-summary-desc-1": "Ethereum è una tecnologia per creare app e organizzazioni, detenere risorse, effettuare transazioni e comunicare senza essere controllati da un'autorità centrale. Non devi comunicare tutti i tuoi dati personali per usare Ethereum, sei tu a mantenere il controllo sui tuoi dati e su cosa è condiviso. Ethereum ha la propria criptovaluta, Ether, usata per pagare per certe attività sulla rete di Ethereum.", - "page-what-is-ethereum-summary-desc-2": "Sei ancora confuso? Spieghiamo tutto passo dopo passo.", + "page-what-is-ethereum-summary-desc-1": "Ethereum è una rete, composta da molte community, nonché una serie di strumenti che consentono alle persone di eseguire transazioni e comunicare, senza il controllo da parte di un'autorità centrale. Non è necessario consegnare tutti i propri dettagli personali per utilizzare Ethereum: sei tu a mantenere il controllo sui tuoi dati e su ciò che viene condiviso. Ethereum ha la propria criptovaluta, l'Ether, utilizzato per pagare certe attività sulla rete di Ethereum.", + "page-what-is-ethereum-summary-desc-2": "Ancora confusi? Spieghiamo tutto, passo dopo passo.", "page-what-is-ethereum-what-is-crypto-title": "Cos'è una criptovaluta?", - "page-what-is-ethereum-what-is-crypto-desc-1": "La cripto (abbreviazione per criptovaluta) è una nuova forma di denaro digitale basata sulla crittografia.", - "page-what-is-ethereum-what-is-crypto-desc-2": "Tutto è iniziato nel 2008 con Bitcoin. Puoi usarla per inviare fondi a chiunque, in qualsiasi luogo del mondo. Ciò che ha reso differente le cripto dai normali trasferimenti bancari o da altri servizi finanziari come PayPal o Alipay è che, per la prima volta, non vi è alcun intermediario.", + "page-what-is-ethereum-what-is-crypto-desc-1": "Le cripto (abbreviazione di criptovalute), sono una nuova forma di denaro digitale, basata sulla crittografia.", + "page-what-is-ethereum-what-is-crypto-desc-2": "Tutto è iniziato nel 2008, con Bitcoin. Era utilizzabile per inviare fondi a chiunque, in tutto il mondo. Ciò che ha reso le cripto differenti dai normali bonifici bancari o da altri servizi finanziari come PayPal o Alipay, era che, per la prima volta, non era presente alcun intermediario.", "page-what-is-ethereum-what-is-crypto-desc-3": "Aspetta, cos'è un intermediario?", - "page-what-is-ethereum-what-is-crypto-desc-4": "Un intermediario è un'autorità centrale, come una banca o un governo, che interviene in una transazione tra il mittente e il destinatario. Ha il potere di sorvegliare, censurare e fermare le transazioni e può condividere i dati sensibili che raccoglie su di te con terze parti. Spesso, inoltre, stabilisce a quali servizi finanziari hai accesso.", - "page-what-is-ethereum-what-is-crypto-desc-5": "Le cose vanno diversamente con le cripto. Le transazioni connettono direttamente mittente e destinatario senza dover avere a che fare con alcuna autorità centrale. Nessun altro avrà accesso ai tuoi fondi e nessuno può dirti che servizi puoi usare. Questo è possibile grazie alla tecnologia della blockchain su cui operano le criptovalute.", + "page-what-is-ethereum-what-is-crypto-desc-4": "Un intermediario è un'autorità centrale, come una banca o un governo, che interviene in una transazione tra il mittente e il destinatario. Ha il potere di sorvegliare, censurare o ripristinare le transazioni e può condividere dati sensibili raccolti su di te, con le terze parti. Inoltre, spesso, definisce a quali servizi finanziari hai accesso.", + "page-what-is-ethereum-what-is-crypto-desc-5": "Le cose sono differenti con le cripto. Le transazioni connettono direttamente il mittente e il destinatario, senza dover affrontare alcuna autorità centrale. Nessun altro avrà accesso ai tuoi fondi e nessuno potrà dirti quali servizi puoi utilizzare. Ciò è possibile grazie alla tecnologia della blockchain, su cui operano le criptovalute.", "page-what-is-ethereum-btc-eth-diff-title": "Qual è la differenza tra Ethereum e Bitcoin?", "page-what-is-ethereum-btc-eth-diff-1": "Lanciato nel 2015, Ethereum si basa sull'innovazione di Bitcoin, con alcune grandi differenze.", - "page-what-is-ethereum-btc-eth-diff-2": "Entrambi ti consentono di usare il denaro digitale senza fornitori di pagamento o banche. Ma Ethereum è programmabile, così puoi anche creare e distribuire delle applicazioni decentralizzate sulla sua rete.", - "page-what-is-ethereum-btc-eth-diff-3": "Ethereum è programmabile nel senso che puoi creare delle app che usano la blockchain per memorizzare i dati o controllare cosa può fare la tua app. Questo genera una blockchain \"a tutto campo\", programmabile per fare tutto. Poiché non c'è limite a cosa Ethereum può fare, rende possibile una grande innovazione sulla rete di Ethereum.", - "page-what-is-ethereum-btc-eth-diff-4": "Mentre Bitcoin è solo una rete di pagamento, Ethereum è più come un mercato di servizi finanziari, giochi, social e altre app che rispettano la tua privacy e non possono censurarti.", + "page-what-is-ethereum-btc-eth-diff-2": "Entrambi ti consentono di utilizzare il denaro digitale senza fornitori di pagamento o banche. Ma Ethereum è programmabile, quindi, puoi anche creare e distribuire applicazioni decentralizzate sulla sua rete.", + "page-what-is-ethereum-btc-eth-diff-3": "Bitcoin consente di inviarci messaggi di base a vicenda, relativi a ciò che pensiamo sia prezioso. Stabilire un valore senza autorità è già di per sé potente. Ethereum estende questo ragionamento: piuttosto che semplici messaggi, puoi scrivere qualsiasi programma generale, o contratto. Non esiste limite al tipo di contratti che possono essere creati e accordati, dunque, sulla rete di Ethereum si verifica grande innovazione.", + "page-what-is-ethereum-btc-eth-diff-4": "Mentre Bitcoin è soltanto una rete di pagamento, Ethereum è più un mercato di servizi finanziari, giochi, social e altre app, che rispettano la tua privacy e non possono censurarti.", "page-what-is-ethereum-what-can-eth-do-title": "Cosa può fare Ethereum?", "page-what-is-ethereum-why-would-i-use-ethereum-title": "Perché dovrei usare Ethereum?", - "page-what-is-ethereum-why-would-i-use-ethereum-1": "Se hai mai inviato denaro all'estero (o prevedi di farlo) o ti sei dovuto preoccupare del futuro delle tue risorse a causa di forze esterne al di fuori del tuo controllo dove vivi o ti sono state date diverse limitazioni e commissioni imposte dalle istituzioni finanziarie tradizionali per le transazioni quotidiane, potresti essere interessato a cosa le criptovalute hanno da offrire.", - "page-what-is-ethereum-why-would-i-use-ethereum-2": "Tieni a mente che Ethereum è una storia che stiamo ancora scrivendo e che emergeranno molti altri motivi per usarlo man mano che si evolve e sviluppa nel tempo.", + "page-what-is-ethereum-why-would-i-use-ethereum-1": "Se hai mai inviato denaro all'estero (o prevedi di farlo), o ti sei dovuto preoccupare del futuro delle tue risorse, a causa di forze esterne, al di fuori del tuo controllo, dove vivi, o hai ricevuto svariate limitazioni e commissioni, imposte dalle istituzioni finanziarie tradizionali per le transazioni quotidiane, potresti avere interesse in ciò che le criptovalute hanno da offrire.", + "page-what-is-ethereum-why-would-i-use-ethereum-2": "Se sei interessato a metodi più resilienti, aperti e affidabili per creare e condividere valore, Ethereum fa per te. Ethereum è la storia scritta da tutti noi, quindi, vieni a scoprire quali incredibili mondi possiamo costruire con esso, insieme.", "page-what-is-ethereum-slide-1-title": "Pagamenti transfrontalieri più economici e veloci", - "page-what-is-ethereum-slide-1-desc-1": "Gli Stablecoin sono un nuovo tipo di criptovaluta che si affida a una risorsa più stabile come base per il suo valore. Gran parte di essi sono collegati al dollaro americano e dunque mantengono il valore di quella valuta. Rendono possibile un sistema di pagamento globale molto economico e stabile. Molti stablecoin correnti sono basati sulla rete di Ethereum.", - "page-what-is-ethereum-slide-1-desc-2": "Ethereum e gli stablecoin semplificano il processo di invio di denaro all'estero. Spesso bastano solo alcuni minuti spostare i fondi in qualunque parte del mondo, rispetto ad alcuni giorni lavorativi o persino settimane che potrebbe impiegare una banca media, e a una frazione del costo. Inoltre, non vi è alcuna commissione aggiuntiva per aver effettuato transazioni di alto valore e non ci sono limitazioni su dove o perché stai inviando il tuo denaro.", + "page-what-is-ethereum-slide-1-desc-1": "Le Stablecoin sono un nuovo tipo di criptovaluta, e si affidano a risorse più stabili come base per il proprio valore. Gran parte di esse sono collegate al dollaro americano e, dunque, mantengono il valore di tale valuta. Queste, consentono un sistema di pagamento molto economico e stabile. Molte stablecoin attuali si basano sulla rete di Ethereum.", + "page-what-is-ethereum-slide-1-desc-2": "Ethereum e le Stablecoin, semplificano il procedimento di invio di denaro all'estero. Spesso, ci vogliono soltanto pochi minuti per spostare fondi per il mondo, rispetto a svariati giorni lavorativi, o persino settimane, che potrebbero essere necessari alla banca media, e per una frazione del prezzo. Inoltre, non è prevista alcuna commissione aggiuntiva per effettuare una transazione ad alto valore e non è prevista alcuna limitazione geografica, o sul perché stai inviando il tuo denaro.", "page-what-is-ethereum-slide-2-title": "L'aiuto più rapido nei momenti di crisi", "page-what-is-ethereum-slide-2-desc-1": "Se sei abbastanza fortunato da avere diverse opzioni bancarie tramite le istituzioni fidate dove vivi, potresti dare per scontata la libertà finanziaria, la sicurezza e la stabilità che offrono. Ma per molte persone in tutto il mondo, che affrontano repressione politica o disagio economico, le istituzioni finanziarie potrebbero non fornire la protezione o i servizi che necessitano.", - "page-what-is-ethereum-slide-2-desc-2": "Quando la guerra, le catastrofi economiche o le repressioni sulle libertà civili hanno colpito i residenti di Venezuela, Cuba, Afghanistan, Nigeria, Bielorussia e Ucraina, le criptovalute hanno costituito la più rapida e spesso la sola opzione per mantenere l'agenzia finanziaria.1 Come visto in questi esempi, le criptovalute come Ethereum possono fornire un accesso libero all'economia globale quando le persone sono tagliate fuori dal resto del mondo. Inoltre, gli stablecoin offrono una riserva di valore quando le valute locali stanno collassando a causa della superinflazione.", - "page-what-is-ethereum-slide-3-title": "Dare potere a creatori", - "page-what-is-ethereum-slide-3-desc-1": "Nel solo 2021, artisti, musicisti, scrittori e altri creatori hanno usato Ethereum per guadagnare complessivamente circa $3,5 miliardi. Questo rende Ethereum una delle più grandi piattaforme globali per creatori, insieme a Spotify, YouTube ed Etsy. Scopri di più.", - "page-what-is-ethereum-slide-4-title": "Dare potere ai giocatori", - "page-what-is-ethereum-slide-4-desc-1": "Recentemente sono emersi i giochi play to earn (in cui i giocatori sono effettivamente premiati per giocare ai giochi) e stanno trasformando l'industria videoludica. Tradizionalmente, spesso è vietato scambiare o trasferire risorse di gioco ad altri giocatori con scambio di denaro reale. Questo forza i giocatori a usare siti web del mercato nero, che sono spesso un rischio di sicurezza. Il gaming nella blockchain abbraccia l'economia di gioco e promuove questo comportamento in modo affidabile.", - "page-what-is-ethereum-slide-4-desc-2": "Inoltre, i giocatori sono incentivati perché possono scambiare token di gioco con denaro reale e dunque essere realmente premiati per il loro tempo di gioco.", + "page-what-is-ethereum-slide-2-desc-2": "Quando la guerra, le catastrofi economiche o le repressioni sulle libertà civili hanno colpito i residenti del Venezuela, di Cuba, dell'Afghanistan, della Nigeria, della Bielorussia e dell'Ucraina, le criptovalute hanno costituito la più rapida e spesso l'unica opzione, per mantenere l'agenzia fiscale.1 Come visto in questi esemi, le criptovalute come Ethereum possono fornire un accesso libero all'economia globale, quando le persone sono tagliate fuori dal mondo esterno. Inoltre, le Stablecoin offrono un deposito di valore, quando le valute legali stanno collassando a causa della superinflazione.", + "page-what-is-ethereum-slide-3-title": "Emancipare i Creatori", + "page-what-is-ethereum-slide-3-desc-1": "Soltanto nel 2021, artisti, musicisti, scrittori e altri creatori, hanno utilizzato Ethereum per guadagnare complessivamente, circa $3,5 miliardi. Questo rende Ethereum una delle più grandi piattaforme per creatori, insieme a Spotify, YouTube ed Etsy. Scopri di più.", + "page-what-is-ethereum-slide-4-title": "Emancipare i Giocatori", + "page-what-is-ethereum-slide-4-desc-1": "Recentemente, sono emersi i giochi \"Play to Earn\" (in cui i giocatori sono effettivamente ricompensati per giocare), che stanno trasformando l'industria videoludica. Tradizionalmente, è spesso proibito scambiare o trasferire risorse di gioco ad altri giocatori, in cambio di denaro reale. Ciò forza i giocatori a utilizzare siti web del mercato nero, incorrendo spesso in rischi di sicurezza. Il gaming sulla blockchain abbraccia l'economia di gioco, promuovendo tali comportamenti in una maniera affidabile.", + "page-what-is-ethereum-slide-4-desc-2": "Inoltre, i giocatori sono incentivati perché possono scambiare i token di gioco con denaro reale, venendo realmente ricompensati per il proprio tempo di gioco.", "page-what-is-ethereum-meet-ether-title": "Incontra ether, la criptovaluta di Ethereum", - "page-what-is-ethereum-meet-ether-desc-1": "Ethereum ha una criptovaluta nativa, detta ether (ETH). È puramente digitale e puoi inviarla a chiunque, in tutto il mondo, istantaneamente. L'offerta di ETH non è controllata da alcun governo o azienda; è decentralizzata e completamente trasparente. Le nuove monete (spesso anche dette token) sono emesse solo dagli staker, che proteggono la rete.", - "page-what-is-ethereum-meet-ether-desc-2": "Ogni azione sulla rete di Ethereum richiede una certa quantità di potenza di calcolo. Questa commissione è pagata sotto forma di ether. Questo significa che serve almeno una piccola quantità di ETH per usare la rete.", + "page-what-is-ethereum-meet-ether-desc-1": "Ethereum ha una criptovaluta nativa, detta ether (ETH). È puramente digitale e puoi inviarla a chiunque, in tutto il mondo, istantaneamente. L'offerta di ETH non è controllata da alcun governo o azienda: è decentralizzata e completamente trasparente. Le nuove monete (comunemente dette token), sono emesse soltanto dagli staker, che proteggono la rete.", + "page-what-is-ethereum-meet-ether-desc-2": "Ogni azione sulla rete di Ethereum richiede una certa quantità di potenza di calcolo. Questa commissione è pagata sotto forma di ether. Ciò significa che necessiti di almeno una piccola quantità di ETH, per poter utilizzare la rete.", "page-what-is-ethereum-what-is-ether": "Cos'è un ether?", "page-what-is-ethereum-get-eth": "Ottieni ETH", "page-what-is-ethereum-what-can-i-do-title": "Cosa posso fare con le monete ETH?", - "page-what-is-ethereum-what-can-i-do-desc-1": "A quanto pare un sacco di cose! Uno degli usi più importanti della tecnologia di Ethereum è la finanza decentralizzata (DeFi) che apre intere aree dei servizi bancari a chiunque abbia una connessione a Internet. Puoi usare il tuo ether come una garanzia per accendere un prestito o fornire liquidità per ricevere interessi sui tuoi fondi.", + "page-what-is-ethereum-what-can-i-do-desc-1": "A quanto pare, un sacco di cose! Uno degli utilizzi più di spicco della tecnologia di Ethereum, è la finanza decentralizzata (DeFi), che apre intere aree dei servizi bancari a chiunque abbia una connessione a Internet. Puoi utilizzare i tuoi ether come garanzia per assumere prestiti, o fornire liquidità per guadagnare interessi suoi tuoi fondi.", "page-what-is-ethereum-explore-applications": "Esplora le applicazioni", - "page-what-is-ethereum-learn-defi": "Scopri di più sulla DeFi", + "page-what-is-ethereum-learn-defi": "Impara sulla DeFi", "page-what-is-ethereum-who-runs-ethereum-title": "Chi controlla Ethereum?", - "page-what-is-ethereum-who-runs-ethereum-desc-1": "Ethereum non è controllato da nessuno. Esiste solamente tramite la partecipazione e cooperazione decentralizzate della community. Ethereum fa uso dei nodi (un computer con una copia dei dati della blockchain di Ethereum), gestiti da volontari, in sostituzione di singoli sistemi server e cloud posseduti dai grandi provider di Internet e servizi.", - "page-what-is-ethereum-who-runs-ethereum-desc-2": "Questi nodi distribuiti, operati da individui e aziende in tutto il mondo, rendono resiliente l'infrastruttura della rete di Ethereum. È dunque molto meno vulnerabile ad attacchi o blocchi. Dal suo lancio nel 2015, Ethereum non hai mai subito momenti di inattività. Ci sono migliaia di nodi individuali che eseguono la rete di Ethereum. Questo rende Ethereum una delle criptovalute più decentralizzate che esistono, seconda solo a Bitcoin.", + "page-what-is-ethereum-who-runs-ethereum-desc-1": "Ethereum non è controllato da una singola entità. Esiste solamente tramite la partecipazione e cooperazione decentralizzata della community. Ethereum utilizza i nodi (computer con una copia dei dati della blockchain di Ethereum), operati da volontari per sostituire i singoli server e sistemi di cloud, posseduti dai più grandi fornitori e servizi dell'Internet.", + "page-what-is-ethereum-who-runs-ethereum-desc-2": "Questi nodi distribuiti, operati da individui e aziende da tutto il mondo, forniscono resilienza all'infrastruttura della rete di Ethereum. Dunque, è molto meno vulnerabile ad hack o arresti imprevisti. Dal suo lancio nel 2015, Ethereum non ha mai sofferto di inattività. Esistono migliaia di nodi individuali che operano la rete di Ethereum. Questo, rende Ethereum una delle criptovalute più decentralizzate là fuori, seconda soltanto a Bitcoin.", "page-what-is-ethereum-run-a-node": "Gestire un nodo", "page-what-is-ethereum-smart-contract-title": "Cosa sono i contratti intelligenti?", - "page-what-is-ethereum-smart-contract-desc-1": "I contratti intelligenti sono semplicemente dei programmi informatici che risiedono sulla blockchain di Ethereum. Sono esclusivamente eseguiti quando innescati da una transazione da un utente (o da un altro contratto). Rendono Ethereum molto flessibile in ciò che può fare e lo distinguono dalle altre criptovalute. Questi programmi sono ciò che ora chiamiamo app decentralizzate, o dapp.", - "page-what-is-ethereum-smart-contract-desc-2": "Hai mai utilizzato un prodotto che ha modificato i propri termini di servizio? O che ha rimosso una funzionalità che trovavi utile? Una volta che un contratto intelligente è pubblicato su Ethereum, sarà online e operativo per tutta l'esistenza di Ethereum. Nemmeno l'autore può disattivarlo. Poiché i contratti intelligenti sono automatizzati, non discriminano alcun utente e sono sempre pronti all'uso.", - "page-what-is-ethereum-smart-contract-desc-3": "Esempi popolari di contratti intelligenti sono le app di prestito, le borse di trading decentralizzate, le assicurazioni, le app di crowdfunding; fondamentalmente, qualsiasi cosa a cui potresti pensare.", + "page-what-is-ethereum-smart-contract-desc-1": "I contratti intelligenti sono semplicemente dei programmi informatici, che risiedono sulla blockchain di Ethereum. Sono esclusivamente eseguiti quando innescati da una transazione da un utente (o da un altro contratto). Rendono Ethereum molto flessibile in ciò che può fare e lo distinguono da altre criptovalute. Questi programmi sono quelli che ora chiamiamo app decentralizzate, o dapp.", + "page-what-is-ethereum-smart-contract-desc-2": "Hai mai utilizzato un prodotto che ha modificato i propri termini di servizio? O rimosso una funzionalità che trovavi utile? Una volta che un contratto intelligente è pubblicato su Ethereum, sarà online e operativo finché Ethereum esisterà. Nemmeno l'autore potrà disattivarlo. Poiché i contratti intelligenti sono automatizzati, non discriminano alcun utente e sono sempre pronti all'uso.", + "page-what-is-ethereum-smart-contract-desc-3": "Esempi popolari di contratti intelligenti sono le app di prestito, le piattaforme di trading decentralizzate, le assicurazioni, le app di crowdfunding; fondamentalmente, qualsiasi cosa a cui potresti pensare.", "page-what-is-ethereum-more-on-smart-contracts": "Di più sui Contratti Intelligenti", "page-what-is-ethereum-explore-dapps": "Esplora le dapp", - "page-what-is-ethereum-criminal-activity-title": "Ho sentito dire che le cripto sono usate come strumenti per le attività criminali. È vero?", - "page-what-is-ethereum-criminal-activity-desc-1": "Come ogni forma di denaro, una parte di esso sarà usato impropriamente. Tuttavia, poiché tutte le transazioni di Ethereum si verificano su una blockchain aperta, è spesso più facile per le autorità tracciare attività illecite rispetto al sistema finanziario tradizionale, rendendo probabilmente Ethereum una scelta meno attraente per coloro che preferiscono non essere identificati.", - "page-what-is-ethereum-criminal-activity-desc-2": "Secondo i risultati chiave di un rapporto recente dell'Europol, l'Agenzia dell'Unione europea per la Cooperazione delle Forze dell'Ordine, le cripto sono usate molto meno delle valute legali per scopi criminali:", - "page-what-is-ethereum-criminal-activity-desc-3": "\"L'uso delle criptovalute per attività illecite sembra interessare solo una piccola parte dell'economia complessiva della criptovaluta e sembra essere comparativamente inferiore alla quantità di fondi illeciti coinvolti nella finanza tradizionale.\"", - "page-what-is-ethereum-energy-title": "E il consumo energetico di Ethereum invece?", - "page-what-is-ethereum-energy-desc-1": "Il 15 settembre 2002, Ethereum ha eseguito l'aggiornamento della fusione per la transizione di Ethereum da proof-of-work a proof-of-stake.", - "page-what-is-ethereum-energy-desc-2": "Il Merge è stato l'aggiornamento più grande di Ethereum, e ha ridotto il consumo di energia richiesto per proteggere l'ecosistema del 99.95%, creando un network più sicuro per un costo minore. Ethereum adesso è una Blockchain \"low-carbon\", mentre aumenta la propria sicurezza e scalabilità.", - "page-what-is-ethereum-more-on-energy-consumption": "Maggiori informazioni sul consumo energetico", - "page-what-is-ethereum-energy-consumption-chart-legend": "Consumo di energia annuale in TWh/anno", - "energy-consumption-chart-youtube-label": "YouTube", - "energy-consumption-chart-gold-mining-galaxy-label": "Gold mining (Galaxy Digital)", + "page-what-is-ethereum-criminal-activity-title": "Ho sentito dire che le cripto sono utilizzate come strumenti, per attività criminali. È vero?", + "page-what-is-ethereum-criminal-activity-desc-1": "Come ogni forma di denaro, parte di esso sarà utilizzata impropriamente. Tuttavia, poiché tutte le transazioni di Ethereum si verificano su una blockchain aperta, è spesso più facile, per le autorità, monitorare le attività illecite, rispetto che sul sistema finanziario tradizionale, rendendo probabilmente Ethereum una scelta meno attraente per coloro che preferirebbero passare inosservati.", + "page-what-is-ethereum-criminal-activity-desc-2": "Secondo i risultati chiave di un recente rapporto dell'Europol, l'Agenzia dell'Unione Europea per la Cooperazione delle Forze dell'Ordine, le cripto sono utilizzate molto meno delle valute legali, per scopi criminali:", + "page-what-is-ethereum-criminal-activity-desc-3": "\"L'utilizzo delle criptovalute per attività illecite sembra comprendere soltanto una piccola parte dell'economia di criptovalute complessiva, e sembra essere comparativamente inferiore alla quantità di fondi illeciti coinvolta nella finanza tradizionale.\"", + "page-what-is-ethereum-energy-title": "Invece, quanta energia consuma Ethereum?", + "page-what-is-ethereum-energy-desc-1": "Il 15 settembre 2022, Ethereum ha eseguito l'aggiornamento de La Fusione, per la transizione dal proof-of-work al proof-of-stake.", + "page-what-is-ethereum-energy-desc-2": "Quello de La Fusione, è stato il più grande aggiornamento di Ethereum e ha ridotto il consumo energetico necessario per proteggere Ethereum, del 99,95%, creando una rete più sicura, per un costo carbonico molto minore. Ethereum è ora una blockchain a basse emissioni, mentre la sua sicurezza e scalabilità aumentano.", + "page-what-is-ethereum-more-on-energy-consumption": "Di più sul consumo energetico", + "page-what-is-ethereum-energy-consumption-chart-legend": "Consumo Energetico Annuale in TWh/anno", "energy-consumption-chart-global-data-centers-label": "Centri elaborazione dati globali", - "energy-consumption-chart-gold-mining-cbeci-label": "Gold mining (CBECI)", - "energy-consumption-chart-btc-pow-label": "BTC PoW", + "energy-consumption-gold-mining-cbeci-label": "Estrazione dell'oro", + "energy-consumption-chart-btc-pow-label": "PoW di BTC", "energy-consumption-chart-netflix-label": "Netflix", - "energy-consumption-chart-eth-pow-label": "ETH PoW", + "energy-consumption-chart-eth-pow-label": "PoW di ETH", "energy-consumption-chart-gaming-us-label": "Gaming negli Stati Uniti", "energy-consumption-chart-paypal-label": "PayPal", - "energy-consumption-chart-eth-pos-label": "ETH PoS", - "page-what-is-ethereum-the-merge-update": "L'aggiornamento della Fusione", - "page-what-is-ethereum-additional-reading": "Letture di approfondimento", - "page-what-is-ethereum-week-in-ethereum": "Settimana in Ethereum News", - "page-what-is-ethereum-week-in-ethereum-desc": "- Una newsletter settimanale che copre gli sviluppi chiave nell'intero ecosistema.", + "energy-consumption-chart-eth-pos-label": "PoS di ETH", + "page-what-is-ethereum-the-merge-update": "L'aggiornamento de La Fusione", + "page-what-is-ethereum-additional-reading": "Ulteriori letture", + "page-what-is-ethereum-week-in-ethereum": "Notizie La Settimana di Ethereum", + "page-what-is-ethereum-week-in-ethereum-desc": "- Una newsletter settimanale che copre gli sviluppi chiave sull'ecosistema.", + "page-what-is-ethereum-kernel-dreamers": "Kernel", + "page-what-is-ethereum-kernel-dreamers-desc": "Il Sogno di Ethereum", "page-what-is-ethereum-atoms-institutions-blockchains": "Atomi, Istituzioni, Blockchain", "page-what-is-ethereum-atoms-institutions-blockchains-desc": "- Perché le blockchain contano?", "page-what-is-ethereum-ethereum-in-numbers-title": "Ethereum in numeri", - "adoption-chart-column-now-label": "Oggi", + "adoption-chart-column-now-label": "Ora", "adoption-chart-investors-label": "Investitori", "adoption-chart-developers-label": "Sviluppatori", "adoption-chart-companies-label": "Aziende", "adoption-chart-artists-label": "Artisti", "adoption-chart-musicians-label": "Musicisti", "adoption-chart-writers-label": "Scrittori", - "adoption-chart-gamers-label": "Giocatori", + "adoption-chart-gamers-label": "Videogiocatori", "adoption-chart-refugees-label": "Rifugiati" } diff --git a/src/intl/it/template-usecase.json b/src/intl/it/template-usecase.json index 48bd00c25da..06b131bf84c 100644 --- a/src/intl/it/template-usecase.json +++ b/src/intl/it/template-usecase.json @@ -5,7 +5,7 @@ "template-usecase-dropdown-social-networks": "Social network decentralizzati", "template-usecase-dropdown-identity": "Identità decentralizzata", "template-usecase-dropdown": "Casi d'uso di Ethereum", - "template-usecase-banner": "Gli utilizzi di Ethereum si sviluppano ed evolvono costantemente. Aggiungi qualsiasi informazione ritieni possa rendere il contenuto più chiaro e aggiornato.", + "template-usecase-banner": "Gli utilizzi di Ethereum si sviluppano ed evolvono costantemente. Aggiungi qualsiasi informazione pensi possa chiarire o aggiornare i contenuti.", "template-usecase-edit-link": "Modifica pagina", "template-usecase-dropdown-aria": "Menu a discesa dei casi d'uso" } diff --git a/src/intl/ja/page-languages.json b/src/intl/ja/page-languages.json index 41af3daa519..968f5966023 100644 --- a/src/intl/ja/page-languages.json +++ b/src/intl/ja/page-languages.json @@ -1,16 +1,16 @@ { "page-languages-h1": "言語サポート", - "page-languages-interested": "貢献することに興味がありますか？", + "page-languages-interested": "ご協力いただけますか？", "page-languages-learn-more": "翻訳プログラムの詳細はこちら", - "page-languages-meta-desc": "Ethereum.orgのすべてのサポートされている言語のリソースと翻訳者として参加する方法。", - "page-languages-meta-title": "ethereum.org 言語翻訳", - "page-languages-p1": "イーサリアムはグローバルなプロジェクトであり、国籍や言語に関係なく誰もがアクセスできる ethereum.org は重要です。私たちのコミュニティは、このビジョンを実現するために懸命に取り組んできました。", - "page-languages-translations-available": "ethereum.org は以下の言語で利用可能です。", - "page-languages-resources-paragraph": "ethereum.orgのコンテンツの翻訳に加えて、", - "page-languages-resources-link": "整備された多言語でのイーサリアムリソースの一覧を保有しています", - "page-languages-want-more-header": "他の言語でethereum.orgを見たいですか？", + "page-languages-meta-desc": "Ethereum.orgでサポートされているすべての言語リソース、および翻訳者として参加する方法。", + "page-languages-meta-title": "ethereum.orgの外国語翻訳", + "page-languages-p1": "イーサリアムはグローバルなプロジェクトであるため、国籍や言語にかかわらずすべての人がethereum.orgにアクセスできることが非常に重要です。イーサリアム・コミュニティでは、このビジョンを実現するために尽力してきました。", + "page-languages-translations-available": "ethereum.org は、以下の言語で利用可能です。", + "page-languages-resources-paragraph": "ethereum.orgでは、コンテンツの翻訳に加えて、以下を維持しています。", + "page-languages-resources-link": "多くの言語で作成されたイーサリアム関連リソースの管理済みリスト", + "page-languages-want-more-header": "ethereum.orgを他の言語で表示したいですか？", "page-languages-want-more-link": "翻訳プログラム", - "page-languages-want-more-paragraph": "ethereum.orgの翻訳者は常に可能な限り多くの言語でページを翻訳しています。彼らが現在何に取り組んでいるか、またはそれらに参加するためにサインアップするには、以下を読んでください。", + "page-languages-want-more-paragraph": "ethereum.orgの翻訳者は、常に可能なかぎり多くの言語の翻訳版を作成しています。翻訳作業の現在の進行状況や確認したい場合や翻訳プロジェクトへの参加にサインアップする場合は、ethereum.orgの", "page-languages-filter-placeholder": "フィルター", "language-ar": "アラビア語", "language-az": "アゼルバイジャン語", @@ -28,6 +28,7 @@ "language-fr": "フランス語", "language-gl": "ガリシア語", "language-gu": "グジャラート語", + "language-he": "ヘブライ語", "language-hi": "ヒンディー語", "language-hr": "クロアチア語", "language-hu": "ハンガリー語", @@ -45,7 +46,8 @@ "language-ms": "マレー語", "language-nb": "ノルウェー語", "language-nl": "オランダ語", - "language-fil": "フィリピン語", + "language-pcm": "ピジン語（ナイジェリア）", + "language-ph": "フィリピン語", "language-pl": "ポーランド語", "language-pt": "ポルトガル語", "language-pt-br": "ポルトガル語(ブラジル)", diff --git a/src/intl/ja/page-layer-2.json b/src/intl/ja/page-layer-2.json index c8a0a015649..0a059dd340f 100644 --- a/src/intl/ja/page-layer-2.json +++ b/src/intl/ja/page-layer-2.json @@ -30,7 +30,7 @@ "layer-2-why-do-we-need-layer-2-2": "イーサリアムは、1日あたり100万件以上のトランザクションとこれらの各トランザクションに対する高い需要により、現在のネットワーク容量に達してしまっています。イーサリアムの人気と需要により、ガス代が大幅に上昇し、スケーリングソリューションのニーズも高まりました。そこで登場するのがレイヤー2ネットワークです。", "layer-2-why-do-we-need-layer-2-scalability": "スケーラビリティ", "layer-2-why-do-we-need-layer-2-scalability-1": "スケーラビリティの主な目標は、分散化やセキュリティを損なうことなく、トランザクションのスピード(ファイナリティの迅速化) とトランザクションのスループット(1秒あたりのトランザクション量の増加) を向上させることです。", - "layer-2-why-do-we-need-layer-2-scalability-2": "イーサリアムコミュニティは、スケーリング問題により、分散化やセキュリティを犠牲にしないという揺るぎないスタンスを取っています。シャーディングまで、イーサリアムメインネット (レイヤー1) は、1秒間におよそ15件のトランザクションしか処理できません。イーサリアムの需要が高い場合は、ネットワークが混雑し、トランザクションフィーが高くなり、その費用を負担できないユーザーを締め出してしまうことになります。そこで、現在のイーサリアムをスケーリングさせるために登場するのがレイヤー2になります。", + "layer-2-why-do-we-need-layer-2-scalability-2": "イーサリアム・コミュニティは、スケーラビリティを実現する目的で分散化やセキュリティを重視する姿勢を放棄することはないという立場を明確にしています。シャーディングが実行されるまで、イーサリアム・メインネット（レイヤー1）の処理能力はおよそ毎秒15件のトランザクションとなります。イーサリアムの利用需要が高まる場合、ネットワークが混雑し、トランザクションフィーの高騰および高額の手数料を負担できないユーザーの締め出しが発生します。そこで、現時点でイーサリアムのスケーラビリティを実現するために生み出されたのがレイヤー2です。", "layer-2-why-do-we-need-layer-2-scalability-3": "イーサリアムのビジョンの詳細", "layer-2-benefits-of-layer-2-title": "レイヤー2のメリット", "layer-2-lower-fees-title": "安いトランザクションフィー", diff --git a/src/intl/nl/common.json b/src/intl/nl/common.json index 269f568e6e8..7cad892c932 100644 --- a/src/intl/nl/common.json +++ b/src/intl/nl/common.json @@ -1,4 +1,5 @@ { + "account-abstraction": "Accountabstractie", "about-ethereum-org": "Over ethereum.org", "about-us": "Over ons", "aria-toggle-search-button": "Toon/verberg zoekknop", @@ -6,17 +7,20 @@ "zen-mode": "Zen-modus", "beacon-chain": "Beacon Chain", "bridges": "Blockchain-bruggen", + "clear": "Wissen", "close": "Sluiten", "community": "Community", "community-hub": "Community hub", "community-menu": "Community-menu", "contact": "Contact", + "content-standardization": "Inhoudsstandaardisering", "contributing": "Bijdragen", "contributors": "Bijdragers", "contributors-thanks": "Iedereen die bijgedragen heeft aan deze pagina - bedankt!", "cookie-policy": "Cookiebeleid", "copied": "Gekopieerd", "copy": "Kopiëren", + "danksharding": "Danksharding", "dark-mode": "Donker", "data-provided-by": "Gegevensbron:", "decentralized-applications-dapps": "Gedecentraliseerde toepassingen (dapps)", @@ -25,7 +29,24 @@ "developers": "Ontwikkelaars", "developers-home": "Startpagina voor ontwikkelaars", "docs": "Documentatie", + "docsearch-to-select": "Selecteren", + "docsearch-to-navigate": "Navigeren", + "docsearch-to-close": "Sluiten", + "docsearch-search-by": "Zoeken op", + "docsearch-start-recent-searches-title": "Recent", + "docsearch-start-no-recent-searches": "Geen recente zoekopdrachten", + "docsearch-start-save-recent-search": "Deze zoekopdracht opslaan", + "docsearch-start-remove-recent-search": "Deze zoekopdracht verwijderen uit de geschiedenis", + "docsearch-start-favorite-searches": "Favoriet", + "docsearch-start-remove-favorite-search": "Deze zoekopdracht verwijderen uit favorieten", + "docsearch-no-results-text": "Geen resultaten voor", + "docsearch-no-results-suggested-query": "Probeer te zoeken op", + "docsearch-no-results-missing": "Gelooft u dat deze zoekopdracht resultaten moet opleveren?", + "docsearch-no-results-missing-link": "Laat het ons weten.", + "docsearch-error-title": "Kan resultaten niet ophalen", + "docsearch-error-help": "Wellicht wilt u uw netwerkverbinding controleren.", "documentation": "Documentatie", + "down": "Naar beneden", "ecosystem": "Ecosysteem", "edit-page": "Pagina bewerken", "ef-blog": "Ethereum Foundation-blog", @@ -60,15 +81,22 @@ "feedback-widget-thank-you-timing": "2-3 minuten", "feedback-widget-thank-you-cta": "Open korte enquête", "find-wallet": "Zoek wallet", + "future-proofing": "Toekomstbestendigheid", "get-eth": "ETH verkrijgen", "get-involved": "Help mee", "get-started": "Aan de slag", "grants": "Subsidies", "grant-programs": "Ecosysteem-subsidieprogramma's", - "guides-and-resources": "Communitygidsen en -bronnen", + "guides": "Gidsen", + "guides-hub": "Hub voor handleidingen", "history-of-ethereum": "Geschiedenis van Ethereum", "home": "Home", "how-ethereum-works": "Hoe Ethereum werkt", + "how-to-register-an-ethereum-account": "Hoe een Ethereum-account registreren", + "how-to-revoke-token-access": "Hoe toegang via slimme contracten tot uw cryptofondsen herroepen", + "how-to-swap-tokens": "Hoe tokens wisselen", + "how-to-use-a-bridge": "Hoe tokens naar laag 2 bridgen", + "how-to-use-a-wallet": "Hoe een wallet gebruiken", "image": "afbeelding", "in-this-section": "In deze sectie", "individuals": "Personen", @@ -82,6 +110,7 @@ "layer-2": "Laag 2", "learn": "Info", "learn-by-coding": "Leer door coderen", + "learn-hub": "Hub leren", "learn-menu": "Leer menu", "learn-more": "Meer informatie", "less": "Minder", @@ -96,22 +125,30 @@ "nav-developers": "Ontwikkelaars", "nav-developers-docs": "Ontwikkelaarsdocumenten", "nav-primary": "Primair", + "nfts": "NFT's", "no": "Nee", "on-this-page": "Op deze pagina", "open-research": "Onderzoek openen", "page-last-updated": "Pagina laatst bijgewerkt", + "pbs": "Scheiding proposer-builder", "privacy-policy": "Privacybeleid", "private-ethereum": "Private Ethereum", "refresh": "Ververs de pagina.", "return-home": "terug naar startpagina", + "roadmap": "Ethereum-roadmap", "run-a-node": "Run een node", "rollup-component-website": "Website", "rollup-component-developer-docs": "Ontwikkelaarsdocumenten", "rollup-component-technology-and-risk-summary": "Technologie en risicosamenvatting", + "scaling": "Schalen", "search": "Zoeken", + "search-ethereum-org": "Zoeken op ethereum.org", + "secret-leader-election": "Geheime verkiezing van leider", "search-box-blank-state-text": "Zoeken maar!", "search-eth-address": "Dit lijkt op een Ethereum-adres. We verstrekken geen specifieke gegevens. Probeer het te zoeken op een block explorer zoals", "search-no-results": "Geen zoekresulaten", + "single-slot-finality": "Single-slot finaliteit", + "statelessness": "Statelessness", "see-contributors": "Bekijk bijdragers", "set-up-local-env": "Lokale omgeving instellen", "sharding": "Sharden", @@ -122,10 +159,13 @@ "skip-to-main-content": "Naar hoofdinhoud gaan", "smart-contracts": "Smart contracten", "stablecoins": "Stablecoins", + "stake-eth": "Stake ETH", "staking": "Staken", + "style-guide": "Stijlgids", "solo": "Solo staking", "saas": "Staking as a service", "pools": "Gepoolde staking", + "withdrawals": "Opnames staken", "terms-of-use": "Gebruiksvoorwaarden", "translation-banner-body-new": "Je bekijkt deze pagina in het Engels omdat we hem nog niet hebben vertaald. Help ons deze inhoud te vertalen.", "translation-banner-body-update": "Er is een nieuwe versie van deze pagina, maar die is momenteel alleen in het Engels. Help ons de nieuwste versie te vertalen.", @@ -138,11 +178,15 @@ "translation-banner-no-bugs-dont-show-again": "Niet meer tonen", "try-using-search": "Gebruik zoekopdracht om te vinden waar u naar op zoek bent", "tutorials": "Tutorials", + "up": "Naar boven", "use-ethereum": "Ethereum gebruiken", "use-ethereum-menu": "Ethereum-menu gebruiken", + "user-experience": "Gebruikerservaring", + "verkle-trees": "Verkle-bomen", "wallets": "Wallets", "we-couldnt-find-that-page": "We konden die pagina niet vinden", "web3": "Wat is Web3?", + "web3-title": "Web3", "website-last-updated": "Website laatst bijgewerkt", "what-is-ether": "Wat is ether (ETH)?", "what-is-ethereum": "Wat is Ethereum?", @@ -153,6 +197,7 @@ "decentralized-identity": "Gedecentraliseerde identiteit", "yes": "Ja", "zero-knowledge-proofs": "Zero-knowledge proofs", + "ethereum-roadmap": "Ethereum-roadmap", "page-index-meta-title": "Home", - "page-developers-aria-label": "Menu voor ontwikkelaars" + "page-developers-aria-label": "Ontwikkelaars Menu" } diff --git a/src/intl/pt-br/page-staking.json b/src/intl/pt-br/page-staking.json index f58534e782d..025ca6dc70e 100644 --- a/src/intl/pt-br/page-staking.json +++ b/src/intl/pt-br/page-staking.json @@ -40,6 +40,7 @@ "page-staking-learn-more-saas": "Saiba mais sobre staking como um serviço", "page-staking-dropdown-pools": "Staking combinado", "page-staking-dropdown-withdrawals": "Sobre saques", + "page-staking-dropdown-dvt": "Tecnologia do validador distribuída", "page-staking-more-on-pools": "Mais sobre staking combinado", "page-staking-learn-more-pools": "Saiba mais sobre staking combinado", "page-staking-section-what-title": "O que é a staking (participação)?", diff --git a/src/intl/zh-tw/page-eth.json b/src/intl/zh-tw/page-eth.json index 9cce1af8912..1cb3483762d 100644 --- a/src/intl/zh-tw/page-eth.json +++ b/src/intl/zh-tw/page-eth.json @@ -90,5 +90,5 @@ "page-eth-tokens-dao-description": "網路社群時常由代幣持有者共同管理。", "page-eth-whats-defi": "關於去中心化金融的更多資訊", "page-eth-whats-defi-description": "去中心化金融為建立於以太坊的去中心化金融系統。這份概覽將解釋您可以做什麼。", - "page-what-is-ethereum-what-is-ether": "甚麼是以太幣？" + "page-what-is-ethereum-what-is-ether": "甚麼是以太(ETH)？" } diff --git a/src/intl/zh-tw/page-languages.json b/src/intl/zh-tw/page-languages.json index 8810f9c5170..0cbf02ff4a4 100644 --- a/src/intl/zh-tw/page-languages.json +++ b/src/intl/zh-tw/page-languages.json @@ -25,10 +25,10 @@ "language-es": "西班牙語", "language-fa": "波斯文", "language-fi": "芬蘭文", - "language-fil": "菲律賓文", "language-fr": "法文", "language-gl": "加里斯亞文", "language-gu": "古吉拉特文", + "language-he": "希伯來文", "language-hi": "印度文", "language-hr": "克羅埃西亞文", "language-hu": "匈牙利文", @@ -46,6 +46,8 @@ "language-ms": "馬來文", "language-nb": "挪威文", "language-nl": "荷蘭文", + "language-pcm": "奈及利亞皮欽文", + "language-ph": "菲律賓文", "language-pl": "波蘭文", "language-pt": "葡萄牙文", "language-pt-br": "葡萄牙文（巴西）", diff --git a/src/intl/zh-tw/page-layer-2.json b/src/intl/zh-tw/page-layer-2.json index 00917b6d9be..a86ae716795 100644 --- a/src/intl/zh-tw/page-layer-2.json +++ b/src/intl/zh-tw/page-layer-2.json @@ -30,7 +30,7 @@ "layer-2-why-do-we-need-layer-2-2": "以太坊目前已達到網路容量的上限，即每天 100 多萬筆交易，並每筆交易都具有高需求。以太坊的成功和其使用需求導致燃料費大幅上漲。因此，擴容解決方案也迫在眉睫，這就是二層網路誕生的原因。", "layer-2-why-do-we-need-layer-2-scalability": "可擴展性", "layer-2-why-do-we-need-layer-2-scalability-1": "可擴展性的主要目標是在不犧牲去中心化或安全性的情況下提高交易速度（更快達到最終性）和交易吞吐量（每秒更高的交易量）。", - "layer-2-why-do-we-need-layer-2-scalability-2": "以太坊社群採取了堅定的立場，它不會為了擴大規模而放棄去中心化或安全性。直到採用分片為止，以太坊主網（一層網路）僅能夠處理大約每秒 15 筆交易。當使用以太坊的需求提高，網路就會變得壅擠，這就增加了交易費用，而高昂的價格使得使用者難以負擔。這就是我們如今透過二層網路為以太坊擴容的原因。", + "layer-2-why-do-we-need-layer-2-scalability-2": "以太坊社群採取了堅定的立場，他們不會為了擴容而放棄去中心化或安全性。在實施分片之前，以太坊主網（一層網路）只能每秒鐘處理大約 15 筆交易。當使用以太坊的需求增加時，網路就會壅塞，這增加了交易費並迫使負擔不起這些費用的使用者退出。這就是我們如今透過二層網路為以太坊擴容的原因所在。", "layer-2-why-do-we-need-layer-2-scalability-3": "關於以太坊願景的更多訊息", "layer-2-benefits-of-layer-2-title": "二層網路的優點", "layer-2-lower-fees-title": "降低費用", diff --git a/src/intl/zh-tw/page-wallets-find-wallet.json b/src/intl/zh-tw/page-wallets-find-wallet.json index 7ff66a58f4a..d4534550bd0 100644 --- a/src/intl/zh-tw/page-wallets-find-wallet.json +++ b/src/intl/zh-tw/page-wallets-find-wallet.json @@ -89,5 +89,6 @@ "page-find-wallet-browser": "瀏覽器", "page-find-wallet-browser-desc": "有瀏覽器擴充功能的錢包", "page-find-wallet-device": "裝置", - "page-find-choose-to-compare": "選擇比較對象" + "page-find-choose-to-compare": "選擇比較對象", + "page-find-wallet-choose-features": "選擇功能" } diff --git a/src/intl/zh-tw/page-what-is-ethereum.json b/src/intl/zh-tw/page-what-is-ethereum.json index 752dea5718a..1056ceafcf9 100644 --- a/src/intl/zh-tw/page-what-is-ethereum.json +++ b/src/intl/zh-tw/page-what-is-ethereum.json @@ -32,23 +32,23 @@ "page-what-is-ethereum-cryptocurrency-tab-title": "為什麼我們稱之為加密貨幣？", "page-what-is-ethereum-cryptocurrency-tab-content": "區塊鏈使用密碼學技術來確保您的資金安全。多年來，類似的技術已在銀行業中使用以確保貨幣交易的安全性。所以你可以說加密貨幣有銀行級的安全性。", "page-what-is-ethereum-summary-title": "總結", - "page-what-is-ethereum-summary-desc-1": "以太坊是一種用於構建應用程式和組織、持有資產、進行交易和通信而不受中央權威控制的技術。您無須提供個人詳細資料就能夠使用以太坊 - 您可以掌握自己的資料和共享的內容。以太坊有自己的加密貨幣「以太幣」，用於支付以太坊網路上的某些活動。", + "page-what-is-ethereum-summary-desc-1": "以太坊是一個由許多社群和一組工具組成的網路，使人們能夠在不受中心化管理機構控制的情況下進行交易和交流。人們無需交出所有個人詳細資料即可使用以太坊 - 你可以保管自己的資料和共享內容。以太坊有自己的加密貨幣—以太幣，用於支付以太坊網路上的某些活動。", "page-what-is-ethereum-summary-desc-2": "仍然困惑嗎？讓我們一步一步地解釋一切。", "page-what-is-ethereum-what-is-crypto-title": "什麼是加密貨幣？", "page-what-is-ethereum-what-is-crypto-desc-1": "加密貨幣是一種基於密碼學的新型態數位貨幣。", "page-what-is-ethereum-what-is-crypto-desc-2": "這一切都始於 2008 年的比特幣。您可以使用它向全球各地的任何人發送資金。加密貨幣與普通銀行轉帳或 Paypal、支付寶等其他金融服務的不同之處在於，這是第一次在交易雙方之間不需要有中間人。", "page-what-is-ethereum-what-is-crypto-desc-3": "等等，什麼是中間人？", - "page-what-is-ethereum-what-is-crypto-desc-4": "中間人指的是中央機構，如銀行或政府，它們會干預發送方和接收方之間的交易。他們有權監視、審查或恢復交易，並且可以與第三方共享他們收集到的關於您的敏感資訊。它們還經常規定您只能使用哪些金融服務。", + "page-what-is-ethereum-what-is-crypto-desc-4": "中間商指的是中心化管理機構，如銀行或政府，他們會介入發送者和接收者之間的交易。他們有權監視、審查或還原交易，並且可以與第三方共享他們收集到的關於你的敏感資訊。他們還經常規定你只能使用哪些金融服務。", "page-what-is-ethereum-what-is-crypto-desc-5": "加密貨幣則有所不同。交易直接連接發送方和接收方，無需與任何中央機構達成協議。沒有任何人可以使用您的資金，並且沒有任何人會限制您只能使用哪些服務。區塊鏈技術與其之上運行的加密貨幣，使這一切成為可能。", "page-what-is-ethereum-btc-eth-diff-title": "以太坊和比特幣之間有什麼不同？", "page-what-is-ethereum-btc-eth-diff-1": "以太坊於 2015 年推出，建立在比特幣的創新之上，但兩者之間有一些顯著不同。", "page-what-is-ethereum-btc-eth-diff-2": "兩者都允許你使用數位貨幣，而無需支付提供商或銀行。但以太坊是可編程的，因此你也可以在其網路上構建和部署去中心化應用程式。", - "page-what-is-ethereum-btc-eth-diff-3": "以太坊可編程意味著，你可以構建應用程式，使用區塊鏈來儲存資料和控制你的應用程式可以做什麼。這使得一個通用目的的區塊鏈，可以透過編程來做任何事情。由於以太坊可以做的事情沒有限制，它允許以太坊網路上發生巨大的創新。", + "page-what-is-ethereum-btc-eth-diff-3": "比特幣使我們能夠相互發送基本訊息，瞭解我們對於有價值事物的看法。在沒有權威的情況下確定價值已經很強大了。以太坊則更進一步：你可以編寫任何通用程式或合約，而不僅僅是訊息。可以創建和達成共識的合約種類沒有任何限制，因此以太坊網路上時常出現重大創新。", "page-what-is-ethereum-btc-eth-diff-4": "然而比特幣只是一個支付網路，以太坊更像是一個金融服務、遊戲、社交網路和其他應用程式的市場，這些應用程式尊重你的隱私，不能審查你。", "page-what-is-ethereum-what-can-eth-do-title": "以太坊能夠做什麼？", "page-what-is-ethereum-why-would-i-use-ethereum-title": "我為什麼要使用以太坊？", "page-what-is-ethereum-why-would-i-use-ethereum-1": "如果你曾經（或計劃）向海外匯款，或者你的居住地有著你無法控制的外部力量而不得不擔心資產的未來，或者厭倦了傳統金融機構對日常交易施加的眾多限制和費用，你可能對加密貨幣所能提供的東西感興趣。", - "page-what-is-ethereum-why-would-i-use-ethereum-2": "請記住，以太坊是一個仍在撰寫中的故事，它會隨著時間推移而演變和發展，人們就會發現更多使用它的理由。", + "page-what-is-ethereum-why-would-i-use-ethereum-2": "如果想以更具彈性、更開放、可信度更高的方式創造和分享價值，那麼以太坊適合你。以太坊是一個我們所有人共同書寫的故事，所以快來吧，看看憑藉以太坊我們能夠共同建造何等神奇的世界。", "page-what-is-ethereum-slide-1-title": "更便宜和更快捷的跨境支付", "page-what-is-ethereum-slide-1-desc-1": "穩定幣是一種新型的加密貨幣，它依賴於更穩定的資產作為其價值的基礎。它們中的大多數都與美元掛鉤，因此保持該貨幣的價值。這進而形成一個非常便宜和穩定的全球支付系統。當前的許多穩定幣都是建立在以太坊網路上的。", "page-what-is-ethereum-slide-1-desc-2": "以太坊和穩定幣簡化了向海外匯款的過程。相較於普通銀行在全球各地轉移資金可能需要幾個工作日甚至幾週，以太坊通常只需要幾分鐘，而且手續費只是總金額的一小部分。此外，進行高額交易不會收取額外費用，並且對匯款地點或原因不會有任何限制。", @@ -88,10 +88,8 @@ "page-what-is-ethereum-energy-desc-2": "合併是以太坊最大的升級且使保護以太坊所需的能源消耗減少約 99.95%，從而建立一個更安全的網路，同時降低碳成本。以太坊現為低碳區塊鏈，同時提高安全性和可擴展性。", "page-what-is-ethereum-more-on-energy-consumption": "更多關於能源消耗的資訊", "page-what-is-ethereum-energy-consumption-chart-legend": "年度能源消耗 (TWh/年)", - "energy-consumption-chart-youtube-label": "YouTube", - "energy-consumption-chart-gold-mining-galaxy-label": "黃金開採 (Galaxy Digital)", "energy-consumption-chart-global-data-centers-label": "全球資料中心", - "energy-consumption-chart-gold-mining-cbeci-label": "黃金開採（劍橋比特幣電力消耗指數）", + "energy-consumption-gold-mining-cbeci-label": "淘金", "energy-consumption-chart-btc-pow-label": "比特幣工作量證明", "energy-consumption-chart-netflix-label": "網飛", "energy-consumption-chart-eth-pow-label": "以太幣工作量證明", @@ -102,6 +100,8 @@ "page-what-is-ethereum-additional-reading": "延伸閱讀", "page-what-is-ethereum-week-in-ethereum": "以太坊每週新聞", "page-what-is-ethereum-week-in-ethereum-desc": "- 每週資訊，涵蓋整個生態系統的主要發展事項。", + "page-what-is-ethereum-kernel-dreamers": "Kernel", + "page-what-is-ethereum-kernel-dreamers-desc": "以太坊的夢想", "page-what-is-ethereum-atoms-institutions-blockchains": "原子、機構、區塊鏈", "page-what-is-ethereum-atoms-institutions-blockchains-desc": "為什麼區塊鏈很重要？", "page-what-is-ethereum-ethereum-in-numbers-title": "有關以太坊的數字", diff --git a/src/intl/zh/page-dapps.json b/src/intl/zh/page-dapps.json index 5bd96430f69..4ead026cee0 100644 --- a/src/intl/zh/page-dapps.json +++ b/src/intl/zh/page-dapps.json @@ -1,5 +1,6 @@ { "page-dapps-1inch-logo-alt": "1inch徽标", + "page-dapps-dexguru-logo-alt": "DexGuru 徽标", "page-dapps-aave-logo-alt": "Aave徽标", "page-dapps-add-button": "建议去中心化应用", "page-dapps-add-title": "添加去中心化应用", @@ -86,6 +87,7 @@ "page-dapps-dapp-description-token-sets": "自动再平衡的加密投资策略。", "page-dapps-dapp-description-tornado-cash": "在以太坊上发送匿名交易。", "page-dapps-dapp-description-uniswap": "简单地交换代币或提供代币换取%的奖励。", + "page-dapps-dapp-description-dexguru": "去中心化金融交易者的非托管交易终端", "page-dapps-docklink-dapps": "去中心化应用程序简介", "page-dapps-docklink-smart-contracts": "智能合约", "page-dapps-dark-forest-logo-alt": "Dark Forest徽标", diff --git a/src/intl/zh/page-languages.json b/src/intl/zh/page-languages.json index e1c921d0d58..73aab57c259 100644 --- a/src/intl/zh/page-languages.json +++ b/src/intl/zh/page-languages.json @@ -61,7 +61,7 @@ "language-ta": "泰米尔语", "language-tr": "土耳其语", "language-uk": "乌克兰语", - "language-ur-in": "乌尔都语（印度）", + "language-ur": "乌尔都语", "language-uz": "乌兹别克语", "language-vi": "越南语", "language-zh": "中文（简体）", diff --git a/src/intl/zh/page-staking.json b/src/intl/zh/page-staking.json index 94866b95a46..c0aa8dc985d 100644 --- a/src/intl/zh/page-staking.json +++ b/src/intl/zh/page-staking.json @@ -1,7 +1,7 @@ { "comp-withdrawal-comparison-current-title": "当前的质押人", "comp-withdrawal-comparison-current-li-1": "一些用户在最初设置质押存款时可能已经提供了提现地址，这些用户无需再进行其他操作", - "comp-withdrawal-comparison-current-li-2": "大多数的验证者在最初存款时没有提供提款地址，因此需要更新他们的提款凭证。在质押启动板上可以找到关于何时以及如何更新提款凭证的说明。", + "comp-withdrawal-comparison-current-li-2": "大多数质押人在初始存款时没有提供提款地址，他们需要更新其提款凭证。质押启动板提供有关于如何升级提款凭证的说明", "comp-withdrawal-comparison-current-p": "你可以在此处输入您的验证者索引号以查看你是否仍需要更新凭证（此信息可以在你的客户端日志中找到）：", "comp-withdrawal-comparison-new-title": "新的质押人（尚未存款）", "comp-withdrawal-comparison-new-li-1": "默认情况下，如果新质押人想要自动启用奖励支付和提款功能，则需要在使用质押存款命令行界面工具生成其验证者密钥时，提供一个他们控制的以太坊提款地址。", @@ -17,7 +17,7 @@ "comp-withdrawal-credentials-not-upgraded-2": "如何升级的说明目前可以在质押启动板上找到。", "comp-withdrawal-credentials-verify-mainnet": "在主网上进行验证", "comp-withdrawal-credentials-verify-goerli": "在 Goerli 上进行验证", - "page-staking-withdrawals-when": "2023 年 4 月 12 日", + "page-staking-withdrawals-when": "已上线！", "page-staking-image-alt": "插图：Rhino Mascot 的质押启动板。", "page-staking-benefits-1-title": "赚取奖励", "page-staking-benefits-1-description": "有助于网络达成共识的行为将被给予奖励。只要运行将交易正确打包为新区块并检查其他验证者工作的软件，你便会获得奖励，因为这会使区块链保持安全运行。", @@ -40,6 +40,7 @@ "page-staking-learn-more-saas": "详细了解质押即服务", "page-staking-dropdown-pools": "联合质押", "page-staking-dropdown-withdrawals": "关于提款", + "page-staking-dropdown-dvt": "分布式验证者技术", "page-staking-more-on-pools": "更多关于联合质押的信息", "page-staking-learn-more-pools": "详细了解联合质押", "page-staking-section-what-title": "什么是质押？", @@ -149,6 +150,9 @@ "page-staking-stats-box-metric-1": "以太币质押总数", "page-staking-stats-box-metric-2": "验证者总数", "page-staking-stats-box-metric-3": "当前年化利率", + "page-staking-stats-box-metric-1-tooltip": "信标链上质押的以太币总数，不包括超过 32个以太币的余额", + "page-staking-stats-box-metric-2-tooltip": "信标链上当前已激活验证者帐户的数量", + "page-staking-stats-box-metric-3-tooltip": "过去 24 小时内每个验证者的平均年化经济收益", "page-staking-section-comparison-subtitle": "没有一个解决方案可以适用所有质押，每一个都是独一无二的。这里我们将不同质押方法下会产生的风险、奖励和要求进行对比。", "page-staking-section-comparison-rewards-title": "奖励", "page-staking-section-comparison-solo-rewards-li1": "最大奖励 - 直接从协议获取完整奖励", @@ -186,10 +190,10 @@ "page-staking-faq-4-question": "质押已经上线了吗？", "page-staking-faq-4-answer-p1": "是的。质押自 2020 年 12 月 1 日起上线。", "page-staking-faq-4-answer-p2": "这意味着质押目前已上线，用户可以存入以太币，运行验证者客户端，从而开始赚取奖励。", - "page-staking-faq-4-answer-p3": "合并也发生在 2022 年 9 月 15 日，以太坊从那时起就完全由质押的以太币保护。", + "page-staking-faq-4-answer-p3": "上海/卡佩拉升级于 2023 年 4 月 12 日完成，实现了质押提款功能并结束了质押流动性循环。", "page-staking-faq-5-question": "我在什么时候可以提取质押的以太币？", - "page-staking-faq-5-answer-p1": "提款功能预计在下一次网络升级（即上海升级）中推出，该网络升级预计在 2023 年上半年进行，在完成之前可能会有变化。在上海更新后，质押人将能够选择从他们的验证者余额中提取奖励和/或本金存款。", - "page-staking-faq-5-answer-p2": "与此同时，质押人在提出区块时仍将可以赢得费用和矿工可提取价值形式的奖励，可以通过设置的费用接收地址立即获取这些奖励。", + "page-staking-faq-5-answer-p1": "现在！如果他们愿意，质押者可以随意从其验证者余额中提取奖励和/或本金。", + "page-staking-faq-5-answer-p2": "质押人在提出区块时仍将可以赢得费用和最大可提取价值形式的奖励，可以通过设置的费用接收地址立即获取这些奖励。", "page-staking-faq-5-answer-link": "更多关于质押提款的信息", "page-staking-further-reading-1-link": "为什么采用权益证明（2020 年 11 月）", "page-staking-further-reading-author-vitalik-buterin": "Vitalik Buterin", diff --git a/src/intl/zh/page-wallets-find-wallet.json b/src/intl/zh/page-wallets-find-wallet.json index 66067999c67..49f87eeff59 100644 --- a/src/intl/zh/page-wallets-find-wallet.json +++ b/src/intl/zh/page-wallets-find-wallet.json @@ -89,5 +89,6 @@ "page-find-wallet-browser": "浏览器版", "page-find-wallet-browser-desc": "带有浏览器扩展程序的钱包", "page-find-wallet-device": "设备", - "page-find-choose-to-compare": "选择要比较的钱包" + "page-find-choose-to-compare": "选择要比较的钱包", + "page-find-wallet-choose-features": "选择功能" } diff --git a/src/intl/zh/page-what-is-ethereum.json b/src/intl/zh/page-what-is-ethereum.json index 0a75e8dd276..8489d32f03d 100644 --- a/src/intl/zh/page-what-is-ethereum.json +++ b/src/intl/zh/page-what-is-ethereum.json @@ -88,10 +88,8 @@ "page-what-is-ethereum-energy-desc-2": "合并是以太坊规模最大的一次升级，将保护以太坊安全所需的能源消耗减少了 99.95%，同时创建一个更安全、碳成本更低的以太坊网络。以太坊现在成为一种低碳区块链，并且安全性和可扩展性得到增强。", "page-what-is-ethereum-more-on-energy-consumption": "更多关于能源消耗的信息", "page-what-is-ethereum-energy-consumption-chart-legend": "年能源消耗量，单位为亿千瓦时/年", - "energy-consumption-chart-youtube-label": "YouTube", - "energy-consumption-chart-gold-mining-galaxy-label": "黄金开采 (Galaxy Digital)", "energy-consumption-chart-global-data-centers-label": "全球数据中心", - "energy-consumption-chart-gold-mining-cbeci-label": "黄金开采 (CBECI)", + "energy-consumption-gold-mining-cbeci-label": "黄金开采（最小估算值）", "energy-consumption-chart-btc-pow-label": "比特币工作量证明", "energy-consumption-chart-netflix-label": "Netflix", "energy-consumption-chart-eth-pow-label": "以太坊工作量证明", diff --git a/src/pages-conditional/eth.tsx b/src/pages-conditional/eth.tsx index ef5e450440a..deb1c90da1a 100644 --- a/src/pages-conditional/eth.tsx +++ b/src/pages-conditional/eth.tsx @@ -1,6 +1,15 @@ -import React from "react" -import { Center } from "@chakra-ui/react" -import styled from "@emotion/styled" +import React, { ComponentProps } from "react" +import { + Box, + Center, + Flex, + FlexProps, + Heading, + HeadingProps, + ListItem, + Text, + UnorderedList, +} from "@chakra-ui/react" import { GatsbyImage } from "gatsby-plugin-image" import { useTranslation } from "gatsby-plugin-react-i18next" import { graphql, PageProps } from "gatsby" @@ -16,153 +25,233 @@ import InfoBanner from "../components/InfoBanner" import Link from "../components/Link" import HorizontalCard from "../components/HorizontalCard" import PageMetadata from "../components/PageMetadata" -import { - CardContainer, - Content, - Divider, - GrayContainer, - Intro, - LeftColumn, - RightColumn, - TwoColumnContent, - Page, - StyledCard, -} from "../components/SharedStyledComponents" import FeedbackCard from "../components/FeedbackCard" import QuizWidget from "../components/Quiz/QuizWidget" +import Card from "../components/Card" import { getImage, getSrc } from "../utils/image" -import { Context } from "../types" +import type { ChildOnlyProp, Context } from "../types" -const Slogan = styled.p` - font-style: normal; - font-weight: normal; - font-size: 2rem; - line-height: 140%; -` +const Page = (props: ChildOnlyProp) => ( + +) -const Title = styled.h1` - font-size: 0.875rem; - line-height: 140%; - letter-spacing: 0.04em; - font-weight: 500; - margin-bottom: 1rem; - margin-top: 0; - text-transform: uppercase; - color: ${(props) => props.theme.colors.textTableOfContents}; -` +const Content = (props: ChildOnlyProp) => ( + +) -const StyledTwoColumnContent = styled(TwoColumnContent)` - align-items: flex-start; -` +const Divider = () => ( + +) -const Subtitle = styled.p` - font-size: 1.25rem; - line-height: 140%; - color: ${(props) => props.theme.colors.text200}; -` -const SubtitleTwo = styled.p` - font-size: 1.25rem; - line-height: 140%; - margin-bottom: 2rem; - color: ${(props) => props.theme.colors.text300}; -` +const GrayContainer = (props: ChildOnlyProp) => ( + +) -const StyledEthPriceCard = styled(EthPriceCard)` - margin-bottom: 2rem; -` +const Intro = (props: ChildOnlyProp) => ( + +) -const HeroContainer = styled.div` - display: flex; - justify-content: space-between; - @media (max-width: ${(props) => props.theme.breakpoints.m}) { - flex-direction: column-reverse; - } -` +const StyledCard = (props: ComponentProps) => ( + +) -const Hero = styled(GatsbyImage)` - flex: 1 1 100%; - max-width: 800px; - align-self: center; - background-size: cover; - background-repeat: no-repeat; - margin-left: 2rem; - @media (max-width: ${(props) => props.theme.breakpoints.m}) { - margin-left: 0; - width: 100%; - } -` +const Slogan = (props: ChildOnlyProp) => ( + +) -const Header = styled.header` - flex: 1 1 50%; - min-width: 300px; - margin-top: 8rem; - @media (max-width: ${(props) => props.theme.breakpoints.m}) { - margin-top: 1.5rem; - } -` +const Title = (props: ChildOnlyProp) => ( + +) -const H2 = styled.h2` - margin-top: 0; -` +const Subtitle = (props: ChildOnlyProp) => ( + +) -const H4 = styled.h4` - font-weight: 600; -` +const TwoColumnContent = (props: FlexProps) => ( + +) -const StyledCardContainer = styled(CardContainer)` - margin-bottom: 2rem; -` +export const LeftColumn = (props: ChildOnlyProp) => ( + +) -const TokenCard = styled(HorizontalCard)` - min-width: 100%; - margin: 0.5rem 0rem; - border-radius: 0px; -` +export const RightColumn = (props: ChildOnlyProp) => ( + +) -const TextDivider = styled.div` - margin-bottom: 2rem; - margin-top: 2rem; - width: 10%; - height: 1px; - background-color: ${(props) => props.theme.colors.searchResultBackground}; - @media (min-width: ${(props) => props.theme.breakpoints.l}) { - align-self: flex-start; - } -` +const SubtitleTwo = (props: ChildOnlyProp) => ( + +) -const CentralColumn = styled.div` - display: flex; - flex-direction: column; - align-items: center; - max-width: 960px; - margin: 4rem auto; -` +const HeroContainer = (props: ChildOnlyProp) => ( + +) -const CentralActionCard = styled(ActionCard)` - flex: none; - margin: 2rem 0; - .action-card-image-wrapper { - padding: 1rem; - } - @media (min-width: ${(props) => props.theme.breakpoints.s}) { - display: flex; +const Hero = (props: ChildOnlyProp) => ( + +) - .action-card-image-wrapper { - min-width: 260px; - } - .action-card-content { - display: flex; - flex-direction: column; - justify-content: center; - margin-left: 1rem; - - p { - margin-bottom: 0; - } - } - } -` +const Header = (props: ChildOnlyProp) => ( + +) + +const H2 = (prop: HeadingProps) => ( + +) + +const H3 = (props: HeadingProps) => ( + +) + +const H4 = (props: HeadingProps) => ( + +) + +const CardContainer = (props: FlexProps) => ( + +) + +const TokenCard = (props: ComponentProps) => ( + +) + +const TextDivider = () => ( + +) + +const CentralColumn = (props: ChildOnlyProp) => ( + +) + +const CentralActionCard = (props: ComponentProps) => ( + +) const tokens = [ { @@ -287,26 +376,28 @@ const EthPage = (props: PageProps) => { - + - + + + -

+ {" "} -

+ - + {benefits.map((benefits, idx) => ( ) => { description={benefits.description} /> ))} - + - + - {" "} + {" "} {" "} @@ -333,34 +424,34 @@ const EthPage = (props: PageProps) => {

-

+ -

+ -
+

-

+ -

-

+ + -

-

+ + {" "} - + - + -

-

+ + {" "} -

-
+ + ) => { image={getImage(data.ethereum)!} /> -
+

-

+ -

-

+ + -

+ -
+ -
+

-

+ -

-

+ + {" "} -

-
    -
  • + + + {" "} – -
    • -
  • + + {" "} – -
    • -
  • + + {" "} – -
    • -
  • + + {" "} – -
    • -
-
+ + + ) => { alt={t("page-eth-cat-img-alt")} maxImageWidth={300} > -
+ -
+ -

+

-

-

+ + -

-

+ + -

-

+ + -

-

+ + -

-

+ + -

+ - + -

+

-

-

+ + {" "} -

-

+ + -

-

+ +

-

+ -

+

-

+ {tokens.map((token, idx) => ( ) => { /> ))} - +
diff --git a/src/pages-conditional/what-is-ethereum.tsx b/src/pages-conditional/what-is-ethereum.tsx index ee845b34b41..c75f042802b 100644 --- a/src/pages-conditional/what-is-ethereum.tsx +++ b/src/pages-conditional/what-is-ethereum.tsx @@ -1,9 +1,19 @@ import React from "react" -import styled from "@emotion/styled" -import { useTheme } from "@emotion/react" import { GatsbyImage } from "gatsby-plugin-image" import { graphql, PageProps } from "gatsby" import { useI18next, useTranslation } from "gatsby-plugin-react-i18next" +import { + Box, + BoxProps, + Center, + Flex, + FlexProps, + Heading, + HeadingProps, + ListItem, + Text, + UnorderedList, +} from "@chakra-ui/react" import Translation from "../components/Translation" import Callout from "../components/Callout" @@ -15,15 +25,6 @@ import Tooltip from "../components/Tooltip" import Tabs from "../components/Tabs" import Icon from "../components/Icon" import Link from "../components/Link" -import { - CardContainer, - Content, - GrayContainer, - Page, - Width60, - Width40, - NoWrapText, -} from "../components/SharedStyledComponents" import { Banner, BannerBody, @@ -36,6 +37,8 @@ import EnergyConsumptionChart from "../components/EnergyConsumptionChart" import Slider, { EmblaSlide } from "../components/Slider" import FeedbackCard from "../components/FeedbackCard" import QuizWidget from "../components/Quiz/QuizWidget" +import StatErrorMessage from "../components/StatErrorMessage" +import StatLoadingMessage from "../components/StatLoadingMessage" import { getLocaleForNumberFormat } from "../utils/translations" import { Lang } from "../utils/languages" @@ -47,181 +50,117 @@ import useFetchStat, { IFetchStat, } from "../hooks/useFetchStat" import { GATSBY_FUNCTIONS_PATH } from "../constants" -import { Context } from "../types" -import StatErrorMessage from "../components/StatErrorMessage" -import StatLoadingMessage from "../components/StatLoadingMessage" -import { Center } from "@chakra-ui/react" - -const Slogan = styled.p` - font-style: normal; - font-weight: normal; - font-size: 2rem; - line-height: 140%; -` - -const Title = styled.h1` - font-size: 0.875rem; - line-height: 140%; - letter-spacing: 0.04em; - font-weight: 500; - margin-bottom: 1rem; - margin-top: 0; - text-transform: uppercase; - color: ${({ theme }) => theme.colors.textTableOfContents}; -` - -const Subtitle = styled.p` - font-size: 1.25rem; - line-height: 140%; - color: ${({ theme }) => theme.colors.text200}; -` - -const HeroContainer = styled.div` - display: flex; - justify-content: space-between; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - flex-direction: column-reverse; - } -` - -const Hero = styled(GatsbyImage)` - flex: 1 1 100%; - max-width: 800px; - background-size: cover; - background-repeat: no-repeat; -` - -const Header = styled.header` - margin-top: 12rem; - @media (max-width: 1280px) { - margin-top: 8rem; - } - @media (max-width: 1160px) { - margin-top: 7rem; - } - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - margin-top: 4rem; - } - @media (max-width: 920px) { - margin-top: 2rem; - } - @media (max-width: 870px) { - margin-top: 1rem; - } - @media (max-width: 840px) { - margin-top: 0; - } -` - -const StyledGrayContainer = styled(GrayContainer)` - padding: 0; - margin: 0; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - margin-top: 0rem; - box-shadow: none; - } -` - -const StyledCard = styled(Card)` - flex: 1 1 30%; - min-width: 240px; - margin: 1rem; - padding: 1.5rem; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - flex: 1 1 30%; - } -` - -const Summary = styled.div` - padding: 1rem; - border-radius: 4px; - background: ${({ theme }) => theme.colors.cardGradient}; - - h2 { - font-size: 1.4rem; - margin-bottom: 1.5rem; - color: ${({ theme }) => theme.colors.text300}; - } - - p:last-child { - margin: 0; - } -` - -const TwoColumnContent = styled.div<{ reverse?: boolean }>` - width: 100%; - display: flex; - align-items: center; - flex-direction: ${({ reverse }) => (reverse ? "row-reverse" : "row")}; - - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - flex-direction: column; - align-items: flex-start; - - & > *:first-child { - margin-bottom: 2rem; - } - } -` - -const Section = styled.div<{ - bgColor?: string - padding?: string -}>` - width: 100%; - padding: ${({ padding }) => padding ?? "3rem 2rem"}; - background-color: ${({ bgColor = "transparent" }) => bgColor}; - - h2 { - margin-top: 0; - } -` - -const Column = styled.div` - flex: 0 0 50%; - max-width: 75%; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - max-width: 100%; - } - margin-bottom: 1.5rem; -` - -const StyledCallout = styled(Callout)` - flex: 1 1 416px; - min-height: 100%; -` - -const TabContent = styled.p` - margin: 0; -` - -const StatPrimary = styled.div` - font-size: 3rem; - margin-bottom: 1rem; - line-height: 1; -` - -const StatDescription = styled.div` - font-size: 1rem; - color: ${({ theme }) => theme.colors.text200}; -` - -const ButtonRow = styled.div` - display: flex; - align-items: center; - margin-top: 1rem; - margin-bottom: 1.45rem; - flex-wrap: wrap; - - & > button, - & > a { - margin-right: 1rem; - - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - margin-bottom: 1rem; - } - } -` +import type { ChildOnlyProp, Context } from "../types" + +const Slogan = (props: ChildOnlyProp) => ( + +) + +const Title = (props: ChildOnlyProp) => ( + +) + +const Subtitle = (props: ChildOnlyProp) => ( + +) + +const Hero = (props: ChildOnlyProp) => ( + +) + +const Summary = (props: BoxProps) => ( + +) + +const Content = (props: ChildOnlyProp) => ( + +) + +const TwoColumnContent = (props: FlexProps) => ( + +) + +const Section = (props: BoxProps) => + +export const Width60 = (props: ChildOnlyProp) => ( + +) + +export const Width40 = (props: ChildOnlyProp) => ( +
+) + +const H2 = (prop: ChildOnlyProp & HeadingProps) => ( + +) + +const H3 = (props: ChildOnlyProp) => ( + +) + +const CardContainer = (props: ChildOnlyProp) => ( + +) + +const Column = (props: ChildOnlyProp) => ( + +) + +const TabContent = (props: ChildOnlyProp) => + +const StatPrimary = (props: ChildOnlyProp) => ( + +) + +const StatDescription = (props: ChildOnlyProp) => ( + +) + +const ButtonRow = (props: ChildOnlyProp) => ( + +) const Stat: React.FC<{ stat: IFetchStat }> = ({ stat }) => { const isLoading = !stat.value @@ -235,12 +174,15 @@ const Stat: React.FC<{ stat: IFetchStat }> = ({ stat }) => { ) } +const NoWrapText = (props: ChildOnlyProp) => ( + +) + const WhatIsEthereumPage = ({ data, }: PageProps) => { const { t } = useTranslation() const { language } = useI18next() - const theme = useTheme() const localeForStatsBoxNumbers = getLocaleForNumberFormat(language as Lang) @@ -339,15 +281,19 @@ const WhatIsEthereumPage = ({ ) return ( - + - -
+ + <Translation id="page-what-is-ethereum-title" /> @@ -362,34 +308,49 @@ const WhatIsEthereumPage = ({ -
- - + + + + + - +
-

+ -

-

+ + -

-

+ + -

+ -
- +
+ -

+

-

-

+ + -

-

+ + -

-

+ + -

-

+ + -

-

+ + -

+
@@ -441,36 +402,40 @@ const WhatIsEthereumPage = ({ -

+

-

-

+ + -

-

+ + -

-

+ + -

-

+ + -

+
-

+

-

+ {cards.map((card, idx) => ( - ))} @@ -479,9 +444,9 @@ const WhatIsEthereumPage = ({
-

+

-

+ 4k+ @@ -610,15 +575,15 @@ const WhatIsEthereumPage = ({
-

+

-

-

+ + -

-

+ + -

+ { @@ -630,45 +595,45 @@ const WhatIsEthereumPage = ({ }} > -

+

-

-

+ + -

-

+ + -

+ -

+

-

-

+ + -

-

+ + -

+ -

+

-

-

+ + -

+ -

+

-

-

+ + -

-

+ + -

+ @@ -678,21 +643,21 @@ const WhatIsEthereumPage = ({
-
+
-

+

-

-

+ + -

-

+ + -

+ @@ -706,17 +671,17 @@ const WhatIsEthereumPage = ({
- + -

+

-

-

+ + -

+ @@ -729,21 +694,21 @@ const WhatIsEthereumPage = ({
-
+
-

+

-

-

+ + -

-

+ + -

+ @@ -754,7 +719,7 @@ const WhatIsEthereumPage = ({
- + -

+

-

-

+ + -

-

+ + -

-

+ + -

+ @@ -785,7 +750,7 @@ const WhatIsEthereumPage = ({
- +
@@ -793,54 +758,54 @@ const WhatIsEthereumPage = ({ -

+

-

-

+ + -

-

+ + -

-

- + + + - -

-
    -
  • + + + + Europol Spotlight - Cryptocurrencies - Tracing the evolution of criminal finances.pdf {" "} EN (1.4 MB) -
    • -
  • + + Chainalysis (2021), The 2021 Crypto Crime report {" "} EN -
    • -
+ +
- + -

+

-

-

+ + -

-

+ + -

+ @@ -854,61 +819,65 @@ const WhatIsEthereumPage = ({
-

+

-

-

+ + {" "} -

-

+ + {" "} -

+ -

+ {" "} -

+ -

+

-

+ - -
+ -
- - + + -
+ -
- + + @@ -921,7 +890,7 @@ const WhatIsEthereumPage = ({ - + ) } diff --git a/src/pages/bug-bounty.tsx b/src/pages/bug-bounty.tsx index 154c5ec7325..35c76867642 100644 --- a/src/pages/bug-bounty.tsx +++ b/src/pages/bug-bounty.tsx @@ -118,7 +118,7 @@ const GradientContainer = (props: ChildOnlyProp) => ( px={0} mt={8} bg="cardGradient" - boxShadow="inset 0px 1px 0px tableItemBoxShadow" + boxShadow="inset 0px 1px 0px var(--eth-colors-tableItemBoxShadow)" {...props} /> ) @@ -255,7 +255,7 @@ const StyledGrayContainer = ({ children, ...props }) => ( mt={8} mb={12} bg="grayBackground" - boxShadow="inset 0px 1px 0px tableItemBoxShadow" + boxShadow="inset 0px 1px 0px var(--eth-colors-tableItemBoxShadow)" {...props} > {children} diff --git a/src/pages/languages.tsx b/src/pages/languages.tsx index c59274cfd8c..c32d9449282 100644 --- a/src/pages/languages.tsx +++ b/src/pages/languages.tsx @@ -3,7 +3,6 @@ import { Flex, Heading, IconButton, - Input, LinkBox, LinkOverlay, Text, @@ -14,6 +13,7 @@ import React, { useState } from "react" import { MdClose } from "react-icons/md" import Link from "../components/Link" +import Input from "../components/Input" import PageMetadata from "../components/PageMetadata" import Translation from "../components/Translation" @@ -93,33 +93,24 @@ const LanguagesPage = ({ location }: PageProps) => { w="clamp(min(400px, 100%), 50%, 600px)" > setKeyword(e.target.value)} + rightElement={ + keyword !== "" && ( + } + onClick={resetKeyword} + position="absolute" + insetInlineEnd={1} + aria-label={t("clear")} + variant="icon" + _hover={{ svg: { fill: "primary" } }} + /> + ) + } /> - {keyword !== "" && ( - } - onClick={resetKeyword} - position="absolute" - insetInlineEnd={1} - aria-label={t("clear")} - variant="icon" - _hover={{ svg: { fill: "primary.base" } }} - /> - )} {translationsCompleted.map((lang) => { diff --git a/src/pages/run-a-node.tsx b/src/pages/run-a-node.tsx index 3d01c4e7873..febd70cab1b 100644 --- a/src/pages/run-a-node.tsx +++ b/src/pages/run-a-node.tsx @@ -1,10 +1,22 @@ // Libraries -import React, { ReactNode } from "react" +import React, { ComponentProps, ReactNode } from "react" import { graphql, PageProps } from "gatsby" import { GatsbyImage } from "gatsby-plugin-image" import { useTranslation } from "gatsby-plugin-react-i18next" -import styled from "@emotion/styled" -import { type Icon as ChakraIcon } from "@chakra-ui/react" +import { + Box, + BoxProps, + Center, + CenterProps, + Flex, + FlexProps, + Heading, + HeadingProps, + Img, + Text, + type Icon as ChakraIcon, +} from "@chakra-ui/react" +import { FaDiscord } from "react-icons/fa" // Assets import Dappnode from "../assets/run-a-node/dappnode.svg" @@ -25,369 +37,285 @@ import { import PageHero from "../components/PageHero" import PageMetadata from "../components/PageMetadata" import Translation from "../components/Translation" -import { - Content, - Divider, - Page, - InfoGrid, - Width60, - Width40, -} from "../components/SharedStyledComponents" import ExpandableCard from "../components/ExpandableCard" import ExpandableInfo from "../components/ExpandableInfo" -import Emoji from "../components/OldEmoji" +import Emoji from "../components/Emoji" import Link from "../components/Link" import ButtonLink from "../components/ButtonLink" import FeedbackCard from "../components/FeedbackCard" -import Icon from "../components/Icon" +import Button from "../components/Button" +import { InfoGrid } from "../templates/staking" +import { Width40, Width60 } from "../pages-conditional/what-is-ethereum" // Utils -import { TranslationKey } from "../utils/translations" -import { scrollIntoView } from "../utils/scrollIntoView" import { getImage } from "../utils/image" -// Styles -const GappedPage = styled(Page)` - gap: 4rem; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - gap: 3rem; - } - * { - scroll-margin-top: 5.5rem; - } -` - -const GappedContent = styled(Content)` - display: flex; - flex-direction: column; - gap: 3rem; - padding: 1rem 4rem; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - gap: 2rem; - padding: 1rem 2rem; - } - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - padding: 1rem 0; - } -` - -const HeroContainer = styled.div` - background: ${({ theme }) => theme.colors.runNodeGradient}; - width: 100%; -` - -const Hero = styled(PageHero)` - padding-bottom: 2rem; -` - -const TwoColumnContent = styled.div` - display: flex; - justify-content: space-between; - align-items: center; - margin-bottom: 2rem; - gap: 2rem; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - flex-direction: column; - align-items: flex-start; - margin-left: 0rem; - margin-right: 0rem; - } -` - -const SplitContent = styled.div` - display: flex; - align-items: center; - gap: 2rem; - - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - width: 100%; - flex-direction: column-reverse; - } -` - -const Column = styled.div` - flex: 1; -` - -const ResponsiveButtonLink = styled(ButtonLink)` - gap: 1rem; - padding-left: 2rem; - padding-right: 2rem; - - &:hover { - svg { - fill: ${({ theme }) => theme.colors.buttonColor}; - transform: scale(1.15); - transition: 0.1s; - } - } - @media (max-width: ${({ theme }) => theme.breakpoints.s}) { - width: 100%; - justify-content: center; - } -` - -const Highlight = styled(Content)<{ backgroundColor: string }>` - display: flex; - justify-content: center; - align-items: center; - background: ${({ theme, backgroundColor }) => theme.colors[backgroundColor]}; - border: 1px solid #dadada; - box-sizing: border-box; - border-radius: 4px; - padding: 2rem 6rem; - color: ${({ theme }) => theme.colors.text}; - position: relative; - isolation: isolate; - svg { - margin: 0 0 0 2rem; - } - &:nth-of-type(even) { - flex-direction: row-reverse; - svg { - margin: 0 2rem 0 0; - } - } - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - padding: 2rem; - flex-direction: column-reverse; - &:nth-of-type(even) { - flex-direction: column-reverse; - svg { - margin: 0 0 2rem; - } - } - svg { - margin: 0 0 2rem; - } - } - &::after { - content: ""; - position: absolute; - inset: 0; - z-index: -1; - background: inherit; - filter: blur(1rem); - } -` - -const SoftwareHighlight = styled(Highlight)`` - -const ColumnFill = styled.div` - line-height: 2; - box-sizing: border-box; - flex: 1; - ul { - list-style: none; - } - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - width: 100%; - } -` - -const ColumnNarrow = styled.div` - box-sizing: border-box; - display: flex; - inset: auto; - justify-content: center; - align-items: center; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - width: 100%; - } -` - -const FlexContent = styled(Content)` - display: flex; - flex-direction: column; -` - -const Flex = styled.div` - display: flex; - gap: 2rem; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - flex-direction: column; - } -` - -const MarginFlex = styled(Flex)` - margin: 3rem 0; -` - -const Container = styled.div` - background: ${({ theme }) => theme.colors.grayBackground}; - border: 1px solid #d1d1d1; - box-sizing: border-box; - border-radius: 5px; - color: ${({ theme }) => theme.colors.text}; - padding: 0 2rem; -` - -const BuildBox = styled(Container)` - background: ${({ theme }) => theme.colors.preBackground}; - flex: 1; - padding: 2rem; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - flex-direction: column; - } - - & > p:last-of-type { - margin-bottom: 2rem; - } -` - -const BuildBoxSpace = styled(BuildBox)` - display: flex; - flex-direction: column; - justify-content: space-between; - &:hover { - transform: scale(1.02); - transition: transform 0.1s; - } -` - -const FullyLoaded = styled(Container)` - display: flex; - flex-direction: column; - justify-content: space-between; - line-height: 200%; - padding: 2rem; - flex: 1; - p { - font-size: 110%; - } - code { - font-weight: 600; - line-height: 125%; - } - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - button { - width: fit-content; - padding-left: 2rem; - padding-right: 2rem; - } - } - @media (max-width: ${({ theme }) => theme.breakpoints.s}) { - button { - width: 100%; - } - } - &:hover { - transition: transform 0.1s; - transform: scale(1.02); - } -` - -const SvgTitle = styled.div` - display: flex; - gap: 1rem; - align-items: center; -` - -const ButtonContainer = styled.div` - display: flex; - gap: 1rem; - margin-top: auto; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - flex-direction: column; - } -` - -const DappNodeButtonLink = styled(ResponsiveButtonLink)` - background-color: #007dfc; - span { - color: ${({ theme }) => theme.colors.white}; - } - &:hover { - background-color: #0077be; - box-shadow: 4px 4px 0 0 rgba(#007dfc, 0.47); - } -` - -const AvadoButtonLink = styled(ResponsiveButtonLink)` - background-color: #37822e; - span { - color: ${({ theme }) => theme.colors.white}; - } - &:hover { - background-color: #2e6d2e; - box-shadow: 4px 4px 0 0 rgba(#37822e, 0.47); - } -` - -const StyledEmoji = styled(Emoji)` - margin-right: 1rem; -` - -const BuildContainer = styled(Container)` - flex: 1; - padding: 2rem; - border-radius: none; - border: none; - background: none; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - padding: 2rem 0; - } -` - -const ScrollButtonSecondary = styled.button` - text-decoration: none; - display: inline-block; - padding: 0.5rem 2rem; - margin-top: 1rem; - font-size: 1rem; - border-radius: 0.25em; - text-align: center; - cursor: pointer; - - color: ${({ theme }) => theme.colors.text}; - border: 1px solid ${({ theme }) => theme.colors.text}; - background-color: transparent; - &:hover { - color: ${({ theme }) => theme.colors.primary}; - border: 1px solid ${({ theme }) => theme.colors.primary}; - box-shadow: ${({ theme }) => theme.colors.cardBoxShadow}; - } - &:active { - background-color: ${({ theme }) => - theme.colors.secondaryButtonBackgroundActive}; - } - &:hover { - transition: transform 0.1s; - transform: scale(1.05); - } -` - -const DiscordIcon = styled(Icon)` - fill: ${({ theme }) => theme.colors.buttonColor}; -` - -const StakingCalloutContainer = styled(SplitContent)` - background: linear-gradient( - 262.78deg, - rgba(152, 186, 249, 0.25) 0%, - rgba(207, 177, 251, 0.25) 53.12%, - rgba(151, 252, 246, 0.25) 100% - ); - width: 100%; - padding: 2rem; - gap: 5rem; - @media (max-width: ${({ theme }) => theme.breakpoints.m}) { - flex-direction: column; - gap: 3rem; - } -` - -const Leslie = styled(GatsbyImage)` - transform: scaleX(-1) scale(1.15) translateX(2rem); - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - transform: scaleX(-1) translateY(-3rem); - } -` - -const StrongParagraph = styled.p` - font-size: 150%; - font-weight: 600; -` +import type { ChildOnlyProp } from "../types" + +const Divider = () => + +const GappedPage = (props: ChildOnlyProp) => ( + +) + +const GappedContent = (props: ChildOnlyProp) => ( + +) + +const HeroContainer = (props: ChildOnlyProp) => ( + +) + +const Content = (props: BoxProps) => + +const TwoColumnContent = (props: ChildOnlyProp) => ( + +) + +const SplitContent = (props: FlexProps) => ( + +) + +const Column = (props: ChildOnlyProp) => + +const SoftwareHighlight = (props: CenterProps) => ( +
+) + +const ColumnFill = (props: ChildOnlyProp) => ( + +) + +const ColumnNarrow = (props: ChildOnlyProp) => ( + +) + +const FlexContent = (props: ChildOnlyProp) => ( + +) + +const FlexContainer = (props: FlexProps) => ( + +) + +const MarginFlex = (props: ChildOnlyProp) => ( + +) + +const Container = (props: FlexProps) => ( + +) + +const BuildBox = (props: ComponentProps) => ( + p:last-of-type": { + mb: 8, + }, + "li:last-child": { + mb: 0, + }, + }} + {...props} + /> +) + +const BuildBoxSpace = (props: ChildOnlyProp) => ( + +) + +const FullyLoaded = (props: ChildOnlyProp) => ( + +) + +const SvgTitle = (props: ChildOnlyProp) => ( + +) + +const ButtonContainer = (props: ChildOnlyProp) => ( + +) + +const DappNodeButtonLink = (props: ComponentProps) => ( + +) + +const AvadoButtonLink = (props: ComponentProps) => ( + +) + +const BuildContainer = (props: ChildOnlyProp) => ( + +) + +const StakingCalloutContainer = (props: ChildOnlyProp) => ( + +) + +const StrongParagraph = (props: BoxProps) => ( + +) + +const H2 = (props: HeadingProps) => ( + +) + +const H3 = (props: HeadingProps) => ( + +) + +const H4 = (props: ChildOnlyProp) => ( + +) interface RunANodeCard { image: typeof ChakraIcon @@ -499,33 +427,35 @@ const RunANodePage = ({ data }: PageProps) => { description={t("page-run-a-node-meta-description")} /> - + + + -

+

-

-

+

+

-

-

+ + -

-

+ +

-

-

+ + -

-

+ +

-

-

+ + -

+ @@ -544,15 +474,15 @@ const RunANodePage = ({ data }: PageProps) => { background="runNodeGradient2" forceOpen > -

+ -

-

+ + -

-

+ + -

+ @@ -560,9 +490,9 @@ const RunANodePage = ({ data }: PageProps) => { -

+

-

+ {whyRunANodeCards.map(({ image, title, preview, body, alt }, idx) => { return ( @@ -587,21 +517,24 @@ const RunANodePage = ({ data }: PageProps) => { -

+

-

+ - + -

+ -

-

- - + + + + - -

+ + @@ -615,12 +548,7 @@ const RunANodePage = ({ data }: PageProps) => { - - -

- -

- + ) @@ -628,16 +556,24 @@ const RunANodePage = ({ data }: PageProps) => { alt={t("page-run-a-node-glyph-alt-dappnode")} /> + + + + + - + -

+ -

-

+ + -

+ ) => { -

+

-

-

+ + -

-

+ + -

+ -
-

- + +

+ -

-

+

+ -

+
  • @@ -678,12 +614,12 @@ const RunANodePage = ({ data }: PageProps) => {
  • - + - +
-
+ @@ -695,14 +631,14 @@ const RunANodePage = ({ data }: PageProps) => { -
-

- + +

+ -

-

+

+ -

+
  • @@ -714,20 +650,18 @@ const RunANodePage = ({ data }: PageProps) => {
-
- scrollIntoView("build-your-own")} - > + + -

+

-

+ @@ -736,79 +670,79 @@ const RunANodePage = ({ data }: PageProps) => { // @ts-ignore alt={t("page-run-a-node-glyph-alt-hardware")} /> -

+

-

+ - + -

+

-

+
  • -

    + -

    -

    + + -

    -

    + + -

    +
  • -

    + -

    -

    - - + + + + - - -

    + + +
-

+

-

+
  • -

    - + + - -

    + +
  • -

    - + + - -

    + +
  • -

    - + + - -

    + +
- + @@ -818,21 +752,21 @@ const RunANodePage = ({ data }: PageProps) => { // @ts-ignore alt={t("page-run-a-node-glyph-alt-software")} /> -

+

-

+ - + -
-

+ +

-

-

+

+ -

-
+ + @@ -841,52 +775,54 @@ const RunANodePage = ({ data }: PageProps) => { -
-

+ +

-

-

+

+ -

-

+ + -

-
+ + - - + - - + + - + - + -

+

-

-

+ + -

-

+ + -

+ - - + } + to="https://discord.gg/c28an8dA5k" + > - - + + - + @@ -896,18 +832,18 @@ const RunANodePage = ({ data }: PageProps) => { -

+

-

+
  • {" "} -{" "} - + - +
  • @@ -919,9 +855,9 @@ const RunANodePage = ({ data }: PageProps) => { {" "} -{" "} - + - +
@@ -930,71 +866,79 @@ const RunANodePage = ({ data }: PageProps) => { - + -

+

-

-

+ + -

+ - + - + -

- +

+ -

-

+

+ -

-

+ + {" "} -{" "} -

-

- + +

+ -

-

+

+ -

+
  • {" "} -{" "} - + - +
  • {" "} -{" "} - + - +
  • {" "} -{" "} - + - +
diff --git a/src/pages/staking/deposit-contract.tsx b/src/pages/staking/deposit-contract.tsx index ffe57d22a6b..8dca380e3cc 100644 --- a/src/pages/staking/deposit-contract.tsx +++ b/src/pages/staking/deposit-contract.tsx @@ -6,6 +6,7 @@ import { Box, Button, ButtonProps, + Checkbox, Flex, Heading, Img, @@ -16,7 +17,6 @@ import { import Breadcrumbs from "../../components/Breadcrumbs" import ButtonLink from "../../components/ButtonLink" import CardList from "../../components/CardList" -import Checkbox from "../../components/Checkbox" import CopyToClipboard from "../../components/CopyToClipboard" import Emoji from "../../components/Emoji" import InfoBanner from "../../components/InfoBanner" @@ -358,13 +358,8 @@ const DepositContractPage = ({ setState({ ...state, @@ -375,13 +370,8 @@ const DepositContractPage = ({ setState({ ...state, @@ -392,13 +382,8 @@ const DepositContractPage = ({ setState({ ...state, diff --git a/src/scripts/crowdin-import.ts b/src/scripts/crowdin-import.ts index 3d15b0e31aa..3fba48d46eb 100644 --- a/src/scripts/crowdin-import.ts +++ b/src/scripts/crowdin-import.ts @@ -44,6 +44,7 @@ const USER_SELECTION: UserSelectionObject = { es: [], fa: [], fi: [], + fil: [], fr: [], gl: [], gu: [], @@ -65,7 +66,6 @@ const USER_SELECTION: UserSelectionObject = { nb: [], nl: [], pcm: [], - ph: [], pl: [], pt: [], "pt-br": [], @@ -219,7 +219,7 @@ const scrapeDirectory = ( copyFileSync(source, jsonDestinationPath) // Update .json tracker trackers.langs[repoLangCode].jsonCopyCount++ - } else if (item.endsWith(".md")) { + } else if (item.endsWith(".md") || item.endsWith(".svg")) { const mdDestDirPath: string = join( repoRoot, "src", diff --git a/src/scripts/markdownChecker.ts b/src/scripts/markdownChecker.ts index 9d38dbc4d67..cb26b094933 100644 --- a/src/scripts/markdownChecker.ts +++ b/src/scripts/markdownChecker.ts @@ -108,6 +108,7 @@ interface MatterData { published: Date sidebar: string skill: string + emoji: string } function processFrontmatter(path: string, lang: string): void { @@ -129,6 +130,12 @@ function processFrontmatter(path: string, lang: string): void { ) } + if (frontmatter.emoji) { + if (!/^:\S+:$/.test(frontmatter.emoji)) { + console.error(`Frontmatter for 'emoji' is invalid at ${path}`) + } + } + if (frontmatter.sidebar) { console.error(`Unexpected 'sidebar' frontmatter at ${path}`) } diff --git a/src/templates/docs.tsx b/src/templates/docs.tsx index 532de600f90..99bf13623d5 100644 --- a/src/templates/docs.tsx +++ b/src/templates/docs.tsx @@ -220,7 +220,9 @@ const components = { const Contributors = ( props: ComponentPropsWithoutRef -) => +) => ( + +) const DocsPage = ({ data: { siteData, pageData: mdx }, diff --git a/src/templates/roadmap.tsx b/src/templates/roadmap.tsx index 8cfeea47381..f53ab5f3bbc 100644 --- a/src/templates/roadmap.tsx +++ b/src/templates/roadmap.tsx @@ -3,23 +3,22 @@ import { graphql, PageProps } from "gatsby" import { MDXRenderer } from "gatsby-plugin-mdx" import { GatsbyImage } from "gatsby-plugin-image" import { MDXProvider } from "@mdx-js/react" -import styled from "@emotion/styled" import { + Box, + chakra, Flex, ListItem, - Stack, + Show, + SimpleGrid, Text, UnorderedList, + useToken, Wrap, WrapItem, } from "@chakra-ui/react" import Button from "../components/Button" - import ButtonLink from "../components/ButtonLink" -import ButtonDropdown, { - List as ButtonDropdownList, -} from "../components/ButtonDropdown" import Card from "../components/Card" import ImageCard from "../components/ImageCard" import ExpandableCard from "../components/ExpandableCard" @@ -40,272 +39,86 @@ import TableOfContents, { } from "../components/TableOfContents" import FeedbackCard from "../components/FeedbackCard" import SectionNav from "../components/SectionNav" -import { - Divider, - Paragraph, - Header1, - InfoGrid, -} from "../components/SharedStyledComponents" -import Emoji from "../components/OldEmoji" +import Emoji from "../components/Emoji" import YouTube from "../components/YouTube" import Breadcrumbs from "../components/Breadcrumbs" import RoadmapActionCard from "../components/Roadmap/RoadmapActionCard" import RoadmapImageContent from "../components/Roadmap/RoadmapImageContent" +import { + Page, + InfoColumn, + ContentContainer, + InfoTitle, + MobileButton, + H1, + H2, + H3, + Pre, + StyledButtonDropdown, + MobileButtonDropdown, + Title, + Divider, + Paragraph, +} from "./use-cases" import { isLangRightToLeft, TranslationKey } from "../utils/translations" -import { Context } from "../types" import { Lang } from "../utils/languages" import { getImage } from "../utils/image" -const Page = styled.div` - display: flex; - justify-content: space-between; - width: 100%; - margin: 0 auto 4rem; - - @media (min-width: ${(props) => props.theme.breakpoints.l}) { - padding-top: 4rem; - } - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - flex-direction: column; - } -` - -const InfoColumn = styled.aside` - display: flex; - flex-direction: column; - position: sticky; - top: 6.25rem; /* account for navbar */ - height: calc(100vh - 80px); - flex: 0 1 330px; - margin: 0 2rem; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - display: none; - } -` - -const MobileButton = styled.div` - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - background: ${(props) => props.theme.colors.background}; - box-shadow: 0 -1px 0px ${(props) => props.theme.colors.border}; - width: 100%; - bottom: 0; - position: sticky; - padding: 2rem; - z-index: 99; - margin-bottom: 0rem; - } -` - -// Apply styles for classes within markdown here -const ContentContainer = styled.article` - flex: 1 1 ${(props) => props.theme.breakpoints.l}; - position: relative; - padding: 2rem; - padding-top: 0rem; - p:first-of-type { - margin-top: 0; - } - - .featured { - padding-left: 1rem; - margin-left: -1rem; - border-left: 1px dotted ${(props) => props.theme.colors.primary}; - } - - .citation { - p { - color: ${(props) => props.theme.colors.text200}; - } - } -` - -const Pre = styled.pre` - max-width: 100%; - overflow-x: scroll; - background-color: ${(props) => props.theme.colors.preBackground}; - border-radius: 0.25rem; - padding: 1rem; - border: 1px solid ${(props) => props.theme.colors.preBorder}; - white-space: pre-wrap; -` - -const InfoTitle = styled.h2` - font-size: 3rem; - font-weight: 700; - text-align: right; - margin-top: 0rem; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - text-align: left; - font-size: 2.5rem - display: none; - } -` - -const H2 = styled.h2` - font-size: 2rem; - font-weight: 700; - margin-top: 4rem; - - a { - display: none; - } - - /* Anchor tag styles */ - - a { - position: relative; - display: initial; - opacity: 0; - margin-left: -1.5em; - padding-right: 0.5rem; - font-size: 1rem; - vertical-align: middle; - &:hover { - display: initial; - fill: ${(props) => props.theme.colors.primary}; - opacity: 1; - } - } - - &:hover { - a { - display: initial; - fill: ${(props) => props.theme.colors.primary}; - opacity: 1; - } - } -` - -const H3 = styled.h3` - font-size: 1.5rem; - font-weight: 700; - - a { - display: none; - } - - /* Anchor tag styles */ - - a { - position: relative; - display: initial; - opacity: 0; - margin-left: -1.5em; - padding-right: 0.5rem; - font-size: 1rem; - vertical-align: middle; - &:hover { - display: initial; - fill: ${(props) => props.theme.colors.primary}; - opacity: 1; - } - } - - &:hover { - a { - display: initial; - fill: ${(props) => props.theme.colors.primary}; - opacity: 1; - } - } -` - -const CardGrid = styled.div` - display: grid; - grid-template-columns: repeat(2, 1fr); - - gap: 2rem; - h3 { - margin-top: 0; - } - - @media (max-width: ${(props) => props.theme.breakpoints.m}) { - grid-template-columns: repeat(1, 1fr); - margin: auto; - } -` - -const Title = styled.h1` - font-size: 2.5rem; - font-weight: 700; - margin-top: 1rem; -` - -const SummaryPoint = styled.li` - color: ${(props) => props.theme.colors.text300}; -` - -const StyledButtonDropdown = styled(ButtonDropdown)` - margin-bottom: 2rem; - display: flex; - justify-content: flex-end; - text-align: center; - @media (min-width: ${(props) => props.theme.breakpoints.s}) { - align-self: flex-end; - } -` - -const MobileButtonDropdown = styled(StyledButtonDropdown)` - margin-bottom: 0rem; - display: none; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - display: block; - } -` - -const Container = styled.div` - position: relative; - overflow-x: hidden; -` - -const HeroContainer = styled.div` - display: flex; - align-items: center; - padding: 3rem 2rem; - background: ${({ theme }) => theme.colors.layer2Gradient}; - @media (max-width: ${(props) => props.theme.breakpoints.l}) { - flex-direction: column; - max-height: 100%; - padding-left: 0; - padding-right: 0; - margin-bottom: 2em; - } -` - -const Image = styled(GatsbyImage)` - flex: 1 1 100%; - background-repeat: no-repeat; - right: 0; - bottom: 0; - @media (max-width: ${({ theme }) => theme.breakpoints.l}) { - width: 100%; - height: 100%; - max-width: 538px; - overflow: initial; - align-self: center; - margin: 0; - } -` - -const MobileTableOfContents = styled(TableOfContents)` - position: relative; - z-index: 2; -` - -const TitleCard = styled.div` - padding: 2rem; - display: flex; - flex-direction: column; - justify-content: flex-start; - width: 100%; -` +import type { ChildOnlyProp, Context } from "../types" +import type { List as ButtonDropdownList } from "../components/ButtonDropdown" + +const CardGrid = (props: ChildOnlyProp) => ( + +) + +const HeroContainer = (props: ChildOnlyProp) => ( + +) + +const HeroImage = chakra(GatsbyImage, { + baseStyle: { + alignSelf: { + base: "center", + lg: "normal", + }, + bgRepeat: "no-repeat", + flex: "1 1 100%", + right: 0, + bottom: 0, + width: "full", + height: "full", + overflow: "initial", + maxW: { + base: "538px", + lg: "full", + }, + }, +}) + +const TitleCard = (props: ChildOnlyProp) => ( + +) // Note: you must pass components to MDXProvider in order to render them in markdown files // https://www.gatsbyjs.com/plugins/gatsby-plugin-mdx/#mdxprovider const components = { a: Link, - h1: Header1, + h1: H1, h2: H2, h3: H3, p: Paragraph, @@ -322,7 +135,6 @@ const components = { Card, CardGrid, ImageCard, - InfoGrid, Divider, SectionNav, Pill, @@ -339,6 +151,9 @@ const RoadmapPage = ({ data: { pageData: mdx }, location, }: PageProps) => { + // TODO: Replace with direct token implementation after UI migration is completed + const lgBp = useToken("breakpoints", "lg") + if (!mdx?.frontmatter) throw new Error( "Staking page template query does not return expected values" @@ -402,7 +217,7 @@ const RoadmapPage = ({ } return ( - + @@ -439,9 +254,14 @@ const RoadmapPage = ({ })} )} - + - {mdx.frontmatter.alt - - - {mdx.frontmatter.title} - - {tocItems && ( - - )} - + + + + {mdx.frontmatter.title} + + {tocItems && ( + + )} + + {mdx.body} - - - + + + + + - + ) } diff --git a/src/templates/staking.tsx b/src/templates/staking.tsx index a593c2ba9e7..65174006b6f 100644 --- a/src/templates/staking.tsx +++ b/src/templates/staking.tsx @@ -32,6 +32,7 @@ import MarkdownTable from "../components/MarkdownTable" import Logo from "../components/Logo" import MeetupList from "../components/MeetupList" import PageMetadata from "../components/PageMetadata" +import ProductDisclaimer from "../components/ProductDisclaimer" import RandomAppList from "../components/RandomAppList" import UpgradeTableOfContents from "../components/UpgradeTableOfContents" import TableOfContents, { @@ -119,7 +120,7 @@ const Header4 = (props: ChildOnlyProp) => ( /> ) -const InfoGrid = (props: ChildOnlyProp) => ( +export const InfoGrid = (props: ChildOnlyProp) => ( ) => ( @@ -95,23 +99,6 @@ const InfoColumn = (props: ChildOnlyProp) => ( /> ) -const MobileButton = (props: ChildOnlyProp) => { - const borderColor = useToken("colors", "border") - - return ( - - ) -} - // Apply styles for classes within markdown here const ContentContainer = (props: BoxProps) => ( ( ) -type ButtonDropdownProps = Pick< - ComponentPropsWithRef, - "list" -> - -const StyledButtonDropdown = (props: FlexProps & ButtonDropdownProps) => ( - -) - -const MobileButtonDropdown = (props: ButtonDropdownProps) => ( - -) - const Container = (props: ChildOnlyProp) => ( ) diff --git a/src/templates/use-cases.tsx b/src/templates/use-cases.tsx index c5840f331d6..cabc7809814 100644 --- a/src/templates/use-cases.tsx +++ b/src/templates/use-cases.tsx @@ -1,4 +1,4 @@ -import React from "react" +import React, { ComponentProps } from "react" import { graphql, PageProps } from "gatsby" import { MDXProvider } from "@mdx-js/react" import { MDXRenderer } from "gatsby-plugin-mdx" @@ -25,6 +25,7 @@ import { useTranslation } from "gatsby-plugin-react-i18next" import ButtonLink from "../components/ButtonLink" import ButtonDropdown, { + IProps as ButtonDropdownProps, List as ButtonDropdownList, } from "../components/ButtonDropdown" import BannerNotification from "../components/BannerNotification" @@ -62,19 +63,19 @@ const commonHeadingProps: HeadingProps = { lineHeight: 1.4, } -const H1 = (props: HeadingProps) => ( +export const H1 = (props: HeadingProps) => ( ) -const H2 = (props: HeadingProps) => ( +export const H2 = (props: HeadingProps) => ( ) -const H3 = (props: HeadingProps) => ( +export const H3 = (props: HeadingProps) => ( ) -const H4 = (props: HeadingProps) => ( +export const H4 = (props: HeadingProps) => ( ( /> ) -const Divider = () => +export const Divider = () => -const Pre = (props: ChildOnlyProp) => ( +export const Pre = (props: ChildOnlyProp) => ( ( /> ) -const Paragraph = (props: ChildOnlyProp) => ( +export const Paragraph = (props: ChildOnlyProp) => ( ) @@ -170,7 +171,7 @@ const TitleCard = (props: ChildOnlyProp) => { ) } -const Title = (props: ChildOnlyProp) =>

+export const Title = (props: ChildOnlyProp) =>

const HeroImage = chakra(GatsbyImage, { baseStyle: { @@ -226,24 +227,18 @@ export const InfoTitle = (props: ChildOnlyProp) => ( /> ) -type ButtonDropdownProps = Parameters[0] - -export const StyledButtonDropdown = ( - props: FlexProps & ButtonDropdownProps -) => ( - +export const StyledButtonDropdown = ({ + list, + ...rest +}: FlexProps & Pick) => ( + + + ) -export const MobileButtonDropdown = (props: ButtonDropdownProps) => ( - -) +export const MobileButtonDropdown = ( + props: ComponentProps +) => export const ContentContainer = (props: Pick) => { const lgBp = useToken("breakpoints", "lg") diff --git a/src/types.ts b/src/types.ts index de8dc8d2df3..0c4e59b6b38 100644 --- a/src/types.ts +++ b/src/types.ts @@ -5,7 +5,7 @@ import type { Messages } from "./interfaces" import type { Lang } from "./utils/languages" import { TranslationKey } from "./utils/translations" -export type ChildOnlyProp = { children: ReactNode } +export type ChildOnlyProp = { children?: ReactNode } export type Intl = { language: Lang