Diamond Standard, EIP-2535, был создан Ником Маджем как стандартизированная архитектура для реализации смарт-контрактов через прокси. В этой статье мы рассмотрим плюсы использования Diamond Standard и принципы его работы. Вы узнаете как создать и развернуть приложение блокчейна с помощью Diamond Standard!

-Общий обзор
-Зачем использовать
-Хранилище приложений и алмазное хранилище
-Diamond.sol
-DiamondCut.sol
-LoupeFacet.sol
-Как развернуть Diamond Standard
-Заключение

Общий обзор

Алмазный стандарт работает путем развертывания контракта под названием Diamond.sol. Diamond.sol, затем вызывает другие смарт-контракты через delegatecall(). Это позволяет Diamond.solвыполнять код вызываемого контракта в контексте Diamond.sol. Все контракты, которые вызываются с помощью, delegatecall()называются фасетами. Фасеты можно заменять, удалять и добавлять с течением времени, что позволяет разработчикам создавать модульные приложения на блокчейнах, совместимых с EVM. Алмазный стандарт требует от вас реализации DiamondLoupeFacet.sol. DiamondLoupeFacet.solотвечает за документирование других аспектов вашего протокола. DiamondLoupeFacet.solобеспечивает прозрачность, позволяя пользователям видеть адреса и функции фасетов. Еще одно требование Алмазного стандарта DiamondCutFacet.sol. DiamondCutFacet.solотвечает за все обновления вашего приложения.DiamondCutFacet.solтакже генерирует события при вызове, обеспечивая другой уровень прозрачности для пользователей протокола. Хотя это и не является обязательным требованием, LibDiamond.solэто библиотека, которая предоставляет множество вспомогательных функций для написания приложения с помощью стандарта Diamond. При создании приложения с помощью Diamond Standard вы можете использовать один из двух способов сохранения переменных состояния. Их называют App Storageи Diamond Storage. Мы рассмотрим все компоненты Diamond Standard более подробно в оставшейся части статьи.

Алмазный стандарт имеет три различных варианта реализации. К счастью, если вы решите, что выбрали неправильную реализацию, можно обновить приложение до другой реализации. diamond-1является самой базовой реализацией. Сложность diamond-1проще всего понять, а затраты на газ самые низкие. Не рекомендуется вызывать DiamondLoupeFacet.solфункции по цепочке с diamond-1(или diamond-2) из-за высоких затрат на газ. diamond-3, с другой стороны, выбирает оптимизацию DiamondLoupeFacet.solфункций вызова в цепочке. Компромисс заключается в том, что звонки обходятся дороже DiamondCutFacet.sol. diamond-2очень похоже наdiamond-1, но оптимизирует затраты на газ по сравнению со сложностью для понимания. Вам, как разработчику, решать, какая из этих реализаций лучше всего подходит для вашего приложения.

Из-за сложности Diamond Standard рекомендуется следовать общему шаблону при создании приложений. Я свяжу эти шаблоны внизу статьи вместе с дополнительными материалами для чтения.

Зачем использовать Алмазный стандарт?

Основная критика стандарта Diamond — его сложность (надеюсь, я смогу помочь решить эту проблему). Несмотря на сложность, Diamond Standard обеспечивает следующие преимущества:

• Практических ограничений на размер вашего приложения нет. Все смарт-контракты имеют максимальный размер 24 КБ. Поскольку Diamond Standard использует Diamond.solсвои delegatecall()грани, размер контракта остается относительно небольшим.
• Вы используете только один адрес для множества функций. Опять же, благодаря delegatecall(), вы можете добавить все необходимые функции в один смарт-контракт. Это включает в себя реализацию токенов с тем же адресом, что и ваш протокол.
• Он обеспечивает организованный способ обновления ваших смарт-контрактов. Это может помочь аудиторам понять и защитить ваше приложение.
• Это позволяет вам постепенно обновлять свои смарт-контракты. Вместо повторного развертывания всего контракта вы можете просто добавить, заменить или удалить фасет, чтобы обеспечить желаемую функциональность вашего приложения.
• Это обеспечивает высокий уровень прозрачности для вашего прокси-контракта. Как упоминалось ранее, DiamondLoupeFacet.solпозволяет пользователям видеть, где находятся ваши функции в блокчейне и что они выполняют. Посетите https://louper.dev/ , чтобы проанализировать функциональность смарт-контрактов, использующих преимущества Diamond Standard.
• Практически нет ограничений на количество аспектов, которые можно использовать в вашем приложении. Единственный способ, которым вы не сможете добавить больше фасетов в свой протокол, — это нехватка Diamond.solместа для хранения данных фасетов. Для этого потребуется смехотворно большое количество граней, вплоть до того, что это практически невозможно.
• Фасеты могут быть повторно использованы несколькими Diamond.solконтрактами. Это позволяет экономить на газе при развертывании приложений, которые заимствуют функциональные возможности.
• При желании вы можете запустить оптимизатор с более высокими настройками. Оптимизатор Solidity помогает оптимизировать затраты газа при вызове внешних функций. Однако это увеличивает байт-код развертывания контракта. Это может привести к тому, что ваш смарт-контракт превысит максимальный размер смарт-контракта. Поскольку вы можете развертывать столько аспектов, сколько хотите, вы можете настроить оптимизатор на столько запусков, сколько пожелаете, не беспокоясь о том, что ваш контракт слишком велик.

Есть много причин, по которым вы хотели бы использовать Diamond Standard в своем приложении, но не забывайте слишком усложнять свое приложение. Если ваш протокол может работать с одним смарт-контрактом и ни одно из вышеперечисленных преимуществ не применимо к вашему приложению, нет необходимости использовать Diamond Standard. В конечном итоге это только усложнит ваше приложение и увеличит расходы на газ. Однако, если вы находитесь в ситуации, когда вам нужен шаблон прокси для вашего приложения, я лично рекомендую использовать Diamond Standard.

Хранилище приложений и алмазное хранилище

Архитектура переменных состояния — один из наиболее важных аспектов вашего блокчейн-приложения. Я решил сначала рассмотреть этот раздел, чтобы дать вам хорошее представление о том, как переменные состояния управляются с помощью Diamond Standard. Очевидно, что прокси в значительной степени полагаются на delegatecall()выполнение кода из ваших фасетных контрактов в контексте вашего основного контракта ( Diamond.sol). Поскольку все хранилище наших переменных состояния хранится в Diamond.sol, нам нужно убедиться, что наши переменные не перезаписывают друг друга. Прежде чем мы рассмотрим правильный способ организации наших переменных состояния, давайте рассмотрим пример неправильного способа управления переменными состояния.

Если вы вызовите, setVerySpecialVar()вы увидите, verySpecialVarчто был обновлен до 100! Теперь давайте позвоним setNotSoSpecialVarи посмотрим, что произойдет. Мы видим, notSoSpecialVarчто он все еще не инициализирован и равен 0. Если мы проверим, то verySpecialVarувидим, что сейчас он установлен на 50. Почему? Ну, в схеме хранения NotSpecialVarManagerнет verySpecialVar. Поэтому, когда мы вызываем writeNotSpecialVar()via, delegatecall()мы сообщаем Mainоб обновлении слота хранения с 0 до 50. Solidity не заботится о том, как вы называете свои переменные; он смотрит только на положение слота для хранения.

Имея это в виду, нам нужен способ организовать наши переменные состояния, чтобы мы не перезаписывали наши слоты хранения. Первый способ сделать это — с помощью Diamond Storage.

Diamond Storage использует количество слотов для хранения Solidity в смарт-контракте (2²⁵⁶). Теория, лежащая в основе Diamond Storage, заключается в том, что, поскольку слотов для хранения так много, что если мы хэшируем уникальное значение, мы получим случайный слот для хранения, который почти наверняка не будет конфликтовать с другим слотом для хранения. Это может показаться рискованным, но на самом деле это тот же процесс, который Solidity использует для хранения отображений и динамических массивов. Diamond Storage дает возможность вашим фасетам сохранять переменные состояния, специфичные для их контракта, а также позволяет фасетам совместно использовать переменные состояния, если это необходимо.

Поскольку сложность Diamond Standard требует небольшой настройки, для этих примеров хранения я не буду использовать Diamond Standard. Основная цель этого раздела — понять принципы хранения переменных состояния. Реализация в Diamond Standard в основном такая же.

pragma solidity^0.8.17;0.8.17;

library SharedLib {
// struct that with state variable
struct DiamondStorage {
uint256 sharedVar;
}
// returns a storage variable with our state variable
function diamondStorage() internal pure returns(DiamondStorage storage ds) {
// gets a "random" storage positon by hashing a string
bytes32 storagePosition = keccak256(abi.encode("Diamond.Storage.SharedLib"));
// assigns our struct storage slot to storage position
assembly {
ds.slot := storagePosition
}

}
}
// not the actual Diamond Standard
contract PseudoDiamond {
// delegate calls Facet1 to update sharedVar
function writeToSharedVar(address _facet1, uint256 _value) external {
// writes via delegate call
_facet1.delegatecall(
abi.encodeWithSignature("writeShared(uint256)", _value)
);
}
// delegate calls Facet2 to read sharedVar
function readSharedVar(address _facet2) external returns (uint256) {
// returns result of delegate call
(bool success, bytes memory _valueBytes) = _facet2.delegatecall(
abi.encodeWithSignature("readShared()")
);
// since return value is bytes array we use assembly to retrieve our uint
bytes32 _value;
assembly {
let location := _valueBytes
_value := mload( add(location, 0x20) )
}
return uint256(_value);
}
}
contract Facet1 {
function writeShared(uint256 _value) external {
// initializes the storage struct by calling library function
SharedLib.DiamondStorage storage ds = SharedLib.diamondStorage();
// writes to shared variable
ds.sharedVar = _value;

}
}
contract Facet2 {

function readShared() external view returns (uint256) {
// initializes the storage struct by calling library function
SharedLib.DiamondStorage storage ds = SharedLib.diamondStorage();

// returns shared variable
return ds.sharedVar;

}
}

Если вы позвоните PseudoDiamond.writeSharedVar(), то PseudoDiamond.readSharedVar()увидите свое значение. Используя библиотеку и индексируя «случайный» слот для хранения, мы можем обмениваться переменными между двумя смарт-контрактами. Когда мы используем delegatecall()оба аспекта, он смотрит на позицию хранения структуры DiamondStorageдля доступа к этой переменной. Благодаря явной связи между аспектами того, где мы хотим хранить наши данные, мы предотвращаем коллизии переменных состояния. Если вы хотите иметь переменные состояния только для одного из ваших аспектов, вы можете просто создать библиотеку, аналогичную SharedLib, и реализовать ее только в этом конкретном аспекте.

Хранилище приложений работает немного по-другому. Вы создаете файл Solidity, а внутри этого файла создаете структуру с именем AppStorage. Затем вы помещаете в эту структуру столько переменных состояния, сколько хотите, включая другие структуры. Затем первое, что вы делаете внутри своих смарт-контрактов, — это инициализируете их AppStorage. Это устанавливает слот хранения 0 в начало структуры. Это создает удобочитаемое общее состояние между контрактами. Давайте посмотрим на пример!

pragma solidity^0.8.17;0.8.17;

// struct with state variable
struct StateVars {
uint256 sharedVar;
}
// our app storage struct
struct AppStorage {
StateVars state;
}
// not the actual Diamond Standard
contract PseudoDiamond {
AppStorage s;
// delegate calls Facet1 to update sharedVar
function writeToSharedVar(address _facet1, uint256 _value) external {
// writes via delegate call
_facet1.delegatecall(
abi.encodeWithSignature("writeShared(uint256)", _value)
);
}
// delegate calls Facet2 to read sharedVar
function readSharedVar(address _facet2) external returns (uint256) {
// returns result of delegate call
(bool success, bytes memory _valueBytes) = _facet2.delegatecall(
abi.encodeWithSignature("readShared()")
);
// since return value is bytes array we use assembly to retrieve our uint
bytes32 _value;
assembly {
let location := _valueBytes
_value := mload( add(location, 0x20) )
}
return uint256(_value);
}
}
contract Facet1 {
AppStorage s;
function writeShared(uint256 _value) external {
// writes to our state variable in storage
s.state.sharedVar = _value;
}
}
contract Facet2 {
AppStorage s;

function readShared() external view returns (uint256) {
// returns state variable from app storage
return s.state.sharedVar;
}
}

Если вы посмотрите на значение в слоте хранения 0 для PseudoDiamond, вы увидите 100, что является нашим значением! Важное замечание о App Storage: если вам нужно обновить AppStorage после развертывания, обязательно добавьте новые переменные состояния в конец AppStorage, чтобы предотвратить коллизии хранилища. Лично я предпочитаю App Storage для организации Diamond Storage, но оба они выполняют свою работу. Также стоит отметить, что Diamond Storage и App Storage не являются эксклюзивными. Даже если вы используете App Storage для управления переменными состояния LibDiamond.sol, используйте Diamond Storage для управления данными аспектов.

Diamond.sol

Как упоминалось ранее, Diamond.solэто смарт-контракт, который вызывается при взаимодействии с вашим приложением. Если это помогает думать об этом таким образом, Diamond.sol«управляет» остальной частью вашего приложения. Все фасетные функции будут казаться Diamond.solсобственными функциями .

Давайте сначала посмотрим, что происходит в конструкторе diamond-1.

contract Diamond {

constructor(address _contractOwner, address _diamondCutFacet) payable { constructor(address _contractOwner, address _diamondCutFacet) payable {
LibDiamond.setContractOwner(_contractOwner);
// Add the diamondCut external function from the diamondCutFacet
IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);
bytes4[] memory functionSelectors = new bytes4[](1);
functionSelectors[0] = IDiamondCut.diamondCut.selector;
cut[0] = IDiamondCut.FacetCut({
facetAddress: _diamondCutFacet,
action: IDiamondCut.FacetCutAction.Add,
functionSelectors: functionSelectors
});
LibDiamond.diamondCut(cut, address(0), "");
}
// rest of code
}

Во-первых, вне контракта у нас есть структура, которая форматирует наши данные. Затем мы передаем эту структуру в качестве параметра вместе с другой структурой, которая выглядит так:

struct FacetCut {
address facetAddress;address facetAddress;
FacetCutAction action;
bytes4[] functionSelectors;
}
FacetCutпредоставляет адрес фасета, действие, которое мы хотим выполнить с фасетом (добавить, заменить или удалить), и селекторы функций для функций фасета. Затем мы устанавливаем владельца контракта и добавляем любые данные фасета, предоставленные Diamond. Позже мы более подробно рассмотрим, как это работает. После этого, если мы захотим, мы можем инициализировать переменные состояния. Имейте в виду, что вы никогда не должны выполнять какие-либо назначения переменных состояния в конструкторе фасета, потому что он будет выполнять эту операцию внутри смарт-контракта фасета, а не Diamond.sol.

Пока все выглядит довольно просто, поэтому давайте посмотрим, что происходит в конструкторе для diamond-2и diamond-3.

contract Diamond {

constructor(address _contractOwner, address _diamondCutFacet) payable { constructor(address _contractOwner, address _diamondCutFacet) payable {
LibDiamond.setContractOwner(_contractOwner);
// Add the diamondCut external function from the diamondCutFacet
IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);
bytes4[] memory functionSelectors = new bytes4[](1);
functionSelectors[0] = IDiamondCut.diamondCut.selector;
cut[0] = IDiamondCut.FacetCut({
facetAddress: _diamondCutFacet,
action: IDiamondCut.FacetCutAction.Add,
functionSelectors: functionSelectors
});
LibDiamond.diamondCut(cut, address(0), "");
}
// rest of code
}

На этот раз мы передаем только владельца контракта и адрес DiamondCutFacet.sol. Далее мы назначаем владельца Алмаза. После этого мы добавляем diamondCut()функцию, чтобы мы могли добавить больше аспектов. Мы делаем это, сначала инициализируя массив памяти одним элементом типа struct FacetCut, который мы видели ранее. Затем мы инициализируем другой массив одним элементом. На этот раз это массив bytes4, и он используется для хранения diamondCut()селектора функций . Затем мы назначаем селектор функции массиву, вызывая функцию интерфейса Diamond Cut diamondCutи получая ее селектор. После этого мы можем назначить cut[0]. Мы используем адрес DiamondCutFacet.sol, add (потому что мы хотим добавить эту грань к нашему Алмазу) и массив селекторов функций. Наконец, мы фактически добавляемdiamondCut. Это много незнания того, что происходит под капотом, поэтому, если это поможет, вы можете перечитать этот раздел после того, как мы пройдемся по DiamondCut.sol. Пока просто поймите, что мы добавляем фасеты в конструкторе.

Последняя часть — Diamond.solэто fallback()функция. Вот как мы будем называть наши грани в Diamond Standard. Он выглядит почти одинаково во всех трех реализациях Diamond Standard, так что давайте рассмотрим его!

// Find facet for function that is called and execute the
// function if a facet is found and return any value.
fallback() external payable {
LibDiamond.DiamondStorage storage ds;
bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;
// get diamond storage
assembly {
ds.slot := position
}
// get facet from function selector
address facet = address(bytes20(ds.facets[msg.sig]));
require(facet != address(0), "Diamond: Function does not exist");
// Execute external function from facet using delegatecall and return any value.
assembly {
// copy function selector and any arguments
calldatacopy(0, 0, calldatasize())
// execute function call using the facet
let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
// get any return value
returndatacopy(0, 0, returndatasize())
// return any return value or error back to the caller
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
Первое, что мы делаем, это инициализируем Diamond Storage. Здесь мы будем хранить данные нашего фасета. Далее, где находится разница в fallback()s. Мы смотрим diamond-2выше. Во всех трех мы проверяем, существует ли адрес фасета.
Вот как мы регистрируемся diamond-1:

// get facet from function selector
address facet = ds.facetAddressAndSelectorPosition[msg.sig].facetAddress;
if(facet == address(0)) {
revert FunctionNotFound(msg.sig);
}

Вот как мы регистрируем diamond-3:

// get facet from function selector
address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;
require(facet != address(0), "Diamond: Function does not exist");

Основное различие в трех реализациях заключается в том, что diamond-2мы храним селекторы в сопоставлении 32-байтовых слотов памяти.

Наконец, мы используем Yul для delegatecall()наших аспектов, копируя данные вызова, которые были отправлены на Diamond.sol, и проверяя, был ли вызов успешным.

На этом наш раздел о Diamond.sol. Далее мы рассмотрим, что происходило, когда мы вызывали diamondCut().

DiamondCut.sol

Как мы уже обсуждали, DiamondCut.solотвечает за добавление, удаление и замену граней в нашем Алмазе. Все три реализации используют несколько иной подход, но достигают одной и той же цели. Давайте посмотрим, как работает diamond-1

contract DiamondCutFacet is IDiamondCut {
/// @notice Add/replace/remove any number of functions and optionally execute/// @notice Add/replace/remove any number of functions and optionally execute
/// a function with delegatecall
/// @param _diamondCut Contains the facet addresses and function selectors
/// @param _init The address of the contract or facet to execute _calldata
/// @param _calldata A function call, including function selector and arguments
/// _calldata is executed with delegatecall on _init
function diamondCut(
FacetCut[] calldata _diamondCut,
address _init,
bytes calldata _calldata
) external override {
LibDiamond.enforceIsContractOwner();
LibDiamond.diamondCut(_diamondCut, _init, _calldata);
}
}

Как видите, этот контракт сильно зависит от LibDiamond.sol. Все, что мы делаем, исходя из общего обзора, — это проверяем, что владелец контракта сделал этот вызов, а затем вызываем diamondCut(). Давайте посмотрим, что происходит в LibDiamond.sol. Прежде чем мы это сделаем, я должен указать на одну большую деталь о LibDiamond.sol. LibDiamond.solиспользует исключительно internalфункции. Это добавляет байт-код к нашему контракту, избавляя нас от необходимости использовать другой файл delegatecall().

Хорошо, теперь, когда мы понимаем, как сэкономить на топливе в LibDiamond.sol, давайте посмотрим на код diamondCut().

// Internal function version of diamondCut
function diamondCut(
IDiamondCut.FacetCut[] memory _diamondCut,
address _init,
bytes memory _calldata
) internal {
for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {
bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;
address facetAddress = _diamondCut[facetIndex].facetAddress;
if(functionSelectors.length == 0) {
revert NoSelectorsProvidedForFacetForCut(facetAddress);
}
IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;
if (action == IDiamond.FacetCutAction.Add) {
addFunctions(facetAddress, functionSelectors);
} else if (action == IDiamond.FacetCutAction.Replace) {
replaceFunctions(facetAddress, functionSelectors);
} else if (action == IDiamond.FacetCutAction.Remove) {
removeFunctions(facetAddress, functionSelectors);
} else {
revert IncorrectFacetCutAction(uint8(action));
}
}
emit DiamondCut(_diamondCut, _init, _calldata);
initializeDiamondCut(_init, _calldata);
}

Мы берем те же параметры, что и раньше для этой функции. Сначала мы прокручиваем нашу FacetCutструктуру. Внутри цикла мы получаем наш селектор функций и адрес фасетной функции. Мы удостоверяемся, что селектор фасета действителен, и возвращаемся в противном случае. Затем нам нужно проверить действие, которое мы выполняем с этой конкретной функцией (добавить, заменить или удалить). Найдя действие, мы вызываем вспомогательную функцию, которая коррелирует с этим действием. Затем мы создаем событие, чтобы обеспечить прозрачность для наших пользователей. Наконец, мы проверяем, работает ли наш фасет, initializeDiamondCut()проверяя, имеет ли наш контракт код и может ли он быть вызван через delegatecall()with _calldata.

Теперь, когда мы знаем, как это diamondCut()работает, давайте посмотрим, как мы выполняем каждое действие, начинающееся с Add.

function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal { addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
if(_facetAddress == address(0)) {
revert CannotAddSelectorsToZeroAddress(_functionSelectors);
}
DiamondStorage storage ds = diamondStorage();
uint16 selectorCount = uint16(ds.selectors.length);
enforceHasContractCode(_facetAddress, "LibDiamondCut: Add facet has no code");
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
address oldFacetAddress = ds.facetAddressAndSelectorPosition[selector].facetAddress;
if(oldFacetAddress != address(0)) {
revert CannotAddFunctionToDiamondThatAlreadyExists(selector);
}
ds.facetAddressAndSelectorPosition[selector] = FacetAddressAndSelectorPosition(_facetAddress, selectorCount);
ds.selectors.push(selector);
selectorCount++;
}
}

Входными параметрами являются адрес фасетного контракта и селектор конкретной функции, с которой мы работаем. Мы хотим убедиться, что этот контракт существует, проверив, является ли адрес нулевым адресом. Далее мы инициализируем Diamond Storage. Затем мы получаем количество селекторов, которые уже есть у нашего Алмаза. После этого мы проверяем, есть ли у нашего фасета код контракта. Теперь нам нужно убедиться, что этой функции еще нет в Diamond. Мы делаем это, перебирая селекторы функций и проверяя, существует ли уже адрес. В противном случае мы нажимаем наш селектор на наши сохраненные селекторы.

Теперь давайте посмотрим, как заменить грань!

function replaceFunctions (адрес _facetAddress, bytes4[] memory _functionSelectors) internal { replaceFunctions (адрес _facetAddress, bytes4 [] memory _functionSelectors) internal {
DiamondStorage storage ds = diamondStorage();
if (_facetAddress == address( 0 )) {
revert CannotReplaceFunctionsFromFacetWithZeroAddress (_functionSelectors) ;
}
forceHasContractCode(_facetAddress, " );
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
адрес oldFacetAddress = ds.facetAddressAndSelectorPosition[селектор].facetAddress;
// нельзя заменить неизменяемые функции — в данном случае функции, определенные непосредственно в ромбе
if (oldFacetAddress == address( this )) {
revert CannotReplaceImmutableFunction (selector) ;
}
if (oldFacetAddress == _facetAddress) {
revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet (селектор) ;
}
если (oldFacetAddress == адрес( 0 )) {
вернуть CannotReplaceFunctionThatDoesNotExists (селектор) ;
}
// заменить старый адрес фасета
ds.facetAddressAndSelectorPosition[selector].facetAddress = _facetAddress;
}

Как вы могли заметить, Replaceзапускается так же, как Add. Мы инициализируем Diamond Storage, проверяем, имеет ли фасет допустимый адрес и размер кода, затем прокручиваем селекторы. Во-первых, мы проверяем, является ли селектор неизменным. Затем мы проверяем, является ли функция, которую мы хотим заменить, той же функцией, которую мы добавляем. После этого мы проверяем, действителен ли адрес фасета. В противном случае мы заменяем нашу грань.

Теперь давайте проверим наше последнее действие,

function removeFunctions (адрес _facetAddress, bytes4[] memory _functionSelectors) internal { removeFunctions (адрес _facetAddress, bytes4 [] memory _functionSelectors) internal {
DiamondStorage storage ds = diamondStorage();
uint256 selectorCount = ds.selectors.length;
if (_facetAddress != адрес( 0 )) {
revert RemoveFacetAddressMustBeZeroAddress (_facetAddress) ;
}
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector =_functionSelectors[селекторИндекс];
FacetAddressAndSelectorPosition memory oldFacetAddressAndSelectorPosition = ds.facetAddressAndSelectorPosition[селектор];
if (oldFacetAddressAndSelectorPosition.facetAddress == address( 0 )) {
revert CannotRemoveFunctionThatDoesNotExist (селектор) ;
}

// нельзя удалить неизменяемые функции — функции, определенные непосредственно в ромбе
if (oldFacetAddressAndSelectorPosition.facetAddress == address( this )) {
revert CannotRemoveImmutableFunction (selector) ;
}
// заменить селектор на последний селектор
selectorCount--;
if (oldFacetAddressAndSelectorPosition.selectorPosition!= selectorCount) {
bytes4 lastSelector = ds.selectors[selectorCount];
ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;
ds.facetAddressAndSelectorPosition[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;
}
// удалить последний селектор
ds.selectors.pop();
удалить ds.facetAddressAndSelectorPosition[селектор];

Опять же, мы начинаем с инициализации Diamond Storage, проверяя, имеет ли фасет действительный адрес, а затем прокручиваем селекторы. Затем мы получаем селектор функций и позицию в памяти. Мы проверяем, что он действительно существует, а затем проверяем, что он не является неизменным. После этого мы перемещаем наш селектор в конец массива и выполняем операцию pop()для его удаления.

diamond-2и diamond-3обе достигают той же цели, что и diamond-1функция diamondCut(), но используют другой синтаксис и архитектуру. Для простоты этой статьи мы не будем останавливаться на них. Однако, если достаточное количество людей будет заинтересовано в том, чтобы узнать, как они работают, я могу написать новую статью в будущем, в которой будут более подробно описаны различия в реализациях.

LoupeFacet.sol

Теперь, когда мы понимаем, как обновлять функции в нашем Алмазе, давайте рассмотрим, как мы можем просматривать наши грани. Помните, что for diamond-1и diamond-2не рекомендуется вызывать эти функции по цепочке. diamond-3, однако сильно оптимизирован для вызова этих функций в цепочке. Опять же, мы будем только повторяться diamond-1, но если вы понимаете, что происходит, вы должны быть в состоянии как понять, так и реализовать любую из других реализаций Diamond Standard.

Сначала мы рассмотрим facets(). facets(), возвращает все грани и их селекторы для Diamond.

function facets() external override view returns (Facet[] memory facets_) {facets() external override view returns (Facet[] memory facets_) {
LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
uint256 selectorCount = ds.selectors.length;
// create an array set to the maximum size possible
facets_ = new Facet[](selectorCount);
// create an array for counting the number of selectors for each facet
uint16[] memory numFacetSelectors = new uint16[](selectorCount);
// total number of facets
uint256 numFacets;
// loop through function selectors
for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
bytes4 selector = ds.selectors[selectorIndex];
address facetAddress_ = ds.facetAddressAndSelectorPosition[selector].facetAddress;
bool continueLoop = false;
// find the functionSelectors array for selector and add selector to it
for (uint256 facetIndex; facetIndex < numFacets; facetIndex++) {
if (facets_[facetIndex].facetAddress == facetAddress_) {
facets_[facetIndex].functionSelectors[numFacetSelectors[facetIndex]] = selector;
numFacetSelectors[facetIndex]++;
continueLoop = true;
break;
}
}
// if functionSelectors array exists for selector then continue loop
if (continueLoop) {
continueLoop = false;
continue;
}
// create a new functionSelectors array for selector
facets_[numFacets].facetAddress = facetAddress_;
facets_[numFacets].functionSelectors = new bytes4[](selectorCount);
facets_[numFacets].functionSelectors[0] = selector;
numFacetSelectors[numFacets] = 1;
numFacets++;
}
for (uint256 facetIndex; facetIndex < numFacets; facetIndex++) {
uint256 numSelectors = numFacetSelectors[facetIndex];
bytes4[] memory selectors = facets_[facetIndex].functionSelectors;
// setting the number of selectors
assembly {
mstore(selectors, numSelectors)
}
}
// setting the number of facets
assembly {
mstore(facets_, numFacets)
}
}

Обратите внимание, что входных параметров нет, и мы указываем, что будем возвращать factes_. factes_представляет собой структуру данных, которая выглядит следующим образом:

struct Facet {
address facetAddress;address facetAddress;
bytes4[] functionSelectors;
}

Первое, что мы делаем внутри функции, это инициализируем Diamond Storage. Затем мы получаем количество имеющихся у нас селекторов. После этого мы инициализируем массив, который будем возвращать в конце нашей функции. Затем мы создаем массив для отслеживания количества функций на фасет и переменную для отслеживания количества фасетов. Затем мы прокручиваем наши селекторы функций. Внутри нашего цикла мы ищем, к какому аспекту принадлежит наш селектор. Нам нужно перебрать фасеты, чтобы найти, какой адрес соответствует адресу наших текущих селекторов функций. После того, как мы находим наш фасет, мы добавляем наш селектор функций в массив этого фасета, если он существует. В противном случае мы создаем массив. После того, как мы закончим наш цикл, мы еще раз пройдемся по граням. Внутри этого цикла мы сохраняем количество селекторов в памяти, чтобы вернуться позже. Окончательно, мы сохраняем количество граней и возвращаемся. Причина, по которой мы сохраняем количество селекторов и фасетов, заключается в том, что мы изначально инициализировали наши массивы до максимально возможного размера. Теперь, когда мы знаем, сколько конкретных селекторов и фасетов мы будем возвращать, мы сообщаем Solidity правильный размер возвращаемого массива.

Следующая функция, которую мы рассмотрим, это facetFunctionSelectors(). facetFunctionSelectors()возвращает селекторы функций для определенного аспекта. Он принимает в качестве параметра адрес целевого фасета и возвращает массив, bytes4[]представляющий селекторы функций.

function facetFunctionSelectors(address _facet) external override view returns (bytes4[] memory _facetFunctionSelectors) {facetFunctionSelectors(address _facet) external override view returns (bytes4[] memory _facetFunctionSelectors) {
LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
uint256 selectorCount = ds.selectors.length;
uint256 numSelectors;
_facetFunctionSelectors = new bytes4[](selectorCount);
// loop through function selectors
for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
bytes4 selector = ds.selectors[selectorIndex];
address facetAddress_ = ds.facetAddressAndSelectorPosition[selector].facetAddress;
if (_facet == facetAddress_) {
_facetFunctionSelectors[numSelectors] = selector;
numSelectors++;
}
}
// Set the number of selectors in the array
assembly {
mstore(_facetFunctionSelectors, numSelectors)
}
}

Снова инициализируем Diamond Storage. Затем мы получаем количество селекторов функций и инициализируем наш возвращаемый массив. Далее мы прокручиваем селекторы. Здесь мы проверяем, совпадает ли адрес селектора с нашим целевым аспектом. Если это так, мы сохраняем этот селектор функций. Наконец, мы сохраняем количество селекторов и возвращаемся.

Теперь рассмотрим facetAddresses(), который возвращает массив адресов граней нашего Алмаза.

function facetAddresses() external override view returns (address[] memory facetAddresses_) {facetAddresses() external override view returns (address[] memory facetAddresses_) {
LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
uint256 selectorCount = ds.selectors.length;
// create an array set to the maximum size possible
facetAddresses_ = new address[](selectorCount);
uint256 numFacets;
// loop through function selectors
for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
bytes4 selector = ds.selectors[selectorIndex];
address facetAddress_ = ds.facetAddressAndSelectorPosition[selector].facetAddress;
bool continueLoop = false;
// see if we have collected the address already and break out of loop if we have
for (uint256 facetIndex; facetIndex < numFacets; facetIndex++) {
if (facetAddress_ == facetAddresses_[facetIndex]) {
continueLoop = true;
break;
}
}
// continue loop if we already have the address
if (continueLoop) {
continueLoop = false;
continue;
}
// include address
facetAddresses_[numFacets] = facetAddress_;
numFacets++;
}
// Set the number of facet addresses in the array
assembly {
mstore(facetAddresses_, numFacets)
}
}

Опять же, первое, что мы делаем, это инициализируем Diamond Storage, получаем количество селекторов функций и инициализируем наш возвращаемый массив. Мы также снова просматриваем наши селекторы. Мы проверяем адрес фасета нашего селектора. Затем мы проверяем, видели ли мы этот адрес раньше. Если у нас есть, мы пропускаем эту итерацию цикла. В противном случае мы добавляем этот новый адрес в наш возвращаемый массив. Опять же, мы обновляем размер массива и возвращаем его.

Последняя функция, которую мы рассмотрим, DiamondLoupeFacet.solэто facetAddress. Эта функция возвращает адрес фасета, предоставленного селектором функции.

facetAddress(bytes4 _functionSelector) external override view returns (address facetAddress_) {
LibDiamond.DiamondStorage storage ds

Эта функция довольно проста. Мы инициализируем Diamond Storage и используем то, как мы храним наши селекторы, чтобы вернуть наш адрес фасета.

На этом мы завершаем наш раздел, посвященный аспекту лупы. Теперь мы знаем, как Diamond Standard обеспечивает прозрачность для своих пользователей. Далее мы рассмотрим, как работает развертывание Diamond Standard.

Как развернуть Diamond Standard

При развертывании Diamond вам необходимо развернуть фасеты, а затем развернуть файлы Diamond.sol. Таким образом, вы можете сообщить своему Бриллианту, какие контракты он будет вызывать. Самый простой способ развернуть Diamond — с помощью пакета npm diamond-util. Вот как его установить

npm i diamond-utili diamond-util

После его установки вы можете развернуть свой Diamond с помощью следующего кода.

/ eslint-disable-next-line no-unused-vars
const deployedDiamond = await diamond.deploy({
diamondName: 'LeaseDiamond',
facets: [
'DiamondCutFacet',
'DiamondLoupeFacet',
'Facet1',
'Facet2'
],
args: [/* your parameters */]
})

// init facets
const diamondCutFacet = await ethers.getContractAt('DiamondCutFacet', deployedDiamond.address)
const diamondLoupeFacet = await ethers.getContractAt('DiamondLoupeFacet', deployedDiamond.address)
const facet1 = await ethers.getContractAt('Facet1', deployedDiamond.address)
const facet2 = await ethers.getContractAt('Facet2', deployedDiamond.address)

Эта библиотека берет на себя большую часть работы за нас! Все, что нам нужно сделать, это перечислить наши аспекты, и библиотека развернет их вместе с бриллиантом. Обратите внимание, что когда мы инициализируем наши контракты, ethers.jsмы устанавливаем адрес на Diamond.solадрес .

Если вы хотите добавить новый аспект, вы можете сделать это, вызвав DiamondCutFacet.sol. Вот пример.

const FacetCutAction = { Add: 0, Replace: 1, Remove: 2 }

const Facet3 = await ethers.getContractFactory('Facet3')
const facet3 = await Facet3.deploy()
await facet3.deployed()
const selectors = getSelectors(facet3).remove(['supportsInterface(bytes4)'])
tx = await diamondCutFacet.diamondCut(
[{
facetAddress: facet3.address,
action: FacetCutAction.Add,
functionSelectors: selectors
}],
ethers.constants.AddressZero, '0x', { gasLimit: 800000 }
)

receipt = await tx.wait()

Заключение

Как вы видите, сначала мы развертываем наш фасет. Затем мы используем наш пакет npm для получения селекторов функций. Затем мы вызываем DiamondCutFacet.sol, чтобы обновить наш Diamond. Replace работает аналогично, только вы должны убедиться, что селекторы, которые вы заменяете, уже есть в Diamond. Remove, также работает аналогично, но убедитесь, что селекторы, которые вы передаете, являются теми, которые вы хотите удалить.

Поздравляем! Теперь вы знаете, как создать и развернуть блокчейн-приложение с помощью стандарта Diamond!

Заключение
На этом я завершаю свою статью о стандарте Diamond Standard. Надеюсь, я помог вам разобраться в сложностях стандарта Diamond Standard и понять, как реализовать его в своих собственных проектах.

1 — Настройка подписи DNSSEC

В зависимости от вашего провайдера DNS это может быть очень просто или довольно сложно.

Если ваш DNS-провайдер уже поддерживает домены, подписанные DNSSEC, отлично! Следуйте их инструкциям по настройке DNSSEC.

Если они этого не сделают, вам нужно будет перейти к тому, кто это делает. Я рекомендую либо EasyDNS, либо Google Cloud DNS . Руководство EasyDNS по настройке DNSSEC находится здесь , а руководство Google — здесь .

Независимо от того, какой провайдер вам нужен, убедитесь, что вы выбрали подписи RSA и хеширование SHA256.

После настройки DNSSEC ваш провайдер DNS предоставит вам некоторые данные — записи DS или RRSIG. Вам нужно будет предоставить эти записи вашему регистратору. Это позволяет им вставить соответствующий «клей», чтобы убедиться, что все работает от начала до конца.

Когда вы закончите этот шаг, используйте отладчик Verisign DNSSEC , чтобы убедиться, что все работает, прежде чем двигаться дальше.

2 — Добавление TXT-записи

Регистратор DNS в ENS ищет запись TXT с определенным именем и форматом, чтобы проверить, какой адрес Ethereum должен быть передан во владение доменом.

Чтобы заявить о праве собственности на mydomain.xyz , создайте запись TXT в своей зоне DNS, _ens.mydomain.xyz , с текстовыми данными в форме a=0x1234..., где 0x1234...адрес Ethereum, которому вы хотите передать контроль над записью ENS.

3 — Взаимодействие с оракулом DNSSEC

Затем вам нужно доказать оракулу DNSSEC содержимое созданной вами записи TXT. Для этого вы можете использовать этот инструмент dnsprove , который я написал. Он позаботится обо всей тяжелой работе за вас.

Сначала загрузите инструмент в рабочее пространство golang и скомпилируйте его.

Затем бегите dnsprove --address=0xd7296b6044ffd0565062345c2eaa4017024b2d22 --keyfile=/path/to/keyfile TXT _ens.mydomain.xyz.

Чтобы команда работала, вам необходимо иметь работающий узел Ethereum localhost:8545— или вы можете указать собственное местоположение с помощью --rpc=http://host:port.

Здесь адрес — это адрес оракула DNSSEC на Ropsten. Ключевой файл — это путь к файлу хранилища ключей JSON для учетной записи, которую вы хотите использовать для отправки транзакций.

Прежде чем вы спросите, да, иронично, что эта команда еще не поддерживает имена ENS для указания адреса оракула DNSSEC.

DNSSEC выполнит серию DNS-запросов, чтобы установить цепочку доверия. Затем DNSSEC сверится с оракулом, чтобы увидеть, какие шаги еще не были проверены или устарели.

dnsproveзатем запросит у вас разрешение на отправку транзакций, подтверждающих оставшиеся записи. Как только вы даете свое разрешение, транзакции отправляются, и Ethereum теперь официально осведомлен о ваших записях DNS!

4 — Заявка на ваш домен в ENS

Наконец, вы можете заявить права на свой домен в ENS. В консоли geth выполните следующее:

var registrar = web3.eth.contract([{"константа":true,"inputs":[],"name":"ens","outputs":[{"name":"","type":" адрес"}],"оплачиваемый":ложь,"stateMutability":"представление","тип":"функция"},{"константа":истина,"входы":[],"имя":"rootDomain", "выходы": [{"имя":"","тип":"байты"}],"оплачиваемый":false,"stateMutability":"вид","тип":"функция"},{"константа" :true,"inputs":[],"name":"oracle","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability" :"Посмотреть","тип":"функция"},{"константа":ложь,"входы":[{"имя":"имя","тип":"байты"}],"имя":"требование","выходы" :[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rootNode"," outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs": [{"имя":"_dnssec","тип":"адрес"},{"имя":"_ens","тип":"адрес"},{"имя":"_rootDomain","тип": "bytes"},{"name":"_rootNode","type":"bytes32"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]).at( "0xf8d18b3c5de9892681998076bebcba32e62e0835");function encodeName(buf, off, name) {   if(name == ".") {     buf.writeUInt8(0, off++);     вернуться;   }for(var часть name.split(".")) {     buf.writeUInt8(part.length, off++);     buf.write(part, off)     off += part.length;   }   возврат; }function hexEncodeName(name) {   if(!name.endsWith(".")) name = name + ".";   var buf = новый буфер (имя.длина + 1);   var off = encodeName(buf, 0, name);   вернуть "0x" + buf.toString ("hex", 0, off); }registrar.claim(hexEncodeName('myname.xyz'), {from: myaddress})

Запустите это, и как только транзакция будет добыта, все готово!

Запись ENS, соответствующая myname.xyz, теперь принадлежит вашей учетной записи, и вы можете настроить ее так же, как и любое другое имя — возможно, с помощью manager.ens.domains .

Сегодня мы рассмотрим как использовать ChatGPT для разработчиков, прояснив некоторые детали а так же я покажу расширение VSCode с функциями, подобными ChatGPT.

1. Использование ChatGPT для разработчиков

• Используйте его, чтобы помочь вам найти ошибки в вашем коде . Если у вас есть сегмент кода, который вы не можете отладить, вы можете поместить его в ChatGPT с информацией о том, что вы ожидаете, и что происходит на самом деле. Модель может помочь вам найти проблему.
• Используйте его, чтобы помочь найти пограничные случаи в вашем коде . Модель обладает большой вычислительной мощностью, поэтому она может генерировать крайние случаи, для которых ваш код не сработает, и которые вы, возможно, не сможете определить так быстро.
• Используйте его для идей продукта . Задавая ему вопросы, связанные с продуктом, вы можете быстро получить список возможных вариантов использования вашего программного обеспечения на основе других продуктов и идей, на которых оно обучалось. Обычно это не дает нестандартных идей, но помогает найти пробелы в вашем продукте по сравнению с другими.
• Используйте его для написания тестовых случаев. ChatGPT компетентен в написании юнит-тестов, и получение тестовых случаев из модели невелико, так как они просто не пройдут, если они неверны, и будут явно неправильно сформулированы, если он не тестирует то, что должен. Кроме того, поскольку модульные тесты, как правило, прямолинейны, вероятность того, что модель все сделает правильно, высока, если вы введете формат: протестируйте компонент X с входными данными a, b и c и ожидайте, что на выходе будет Y.
• Используйте его, чтобы получить архитектурные и инфраструктурные варианты . При оценке различных стратегий для задачи, которая, как вы знаете, потребует изменений в инфраструктуре, может быть полезно запросить мнение ChatGPT. Он может дать вам идеи, но не стоит полностью полагаться на его ответ, он должен быть не более чем источником вдохновения, если вы не уверены, куда идти.

2. Как не использовать ChatGPT:

• НЕ используйте его, чтобы научиться программировать . Генерируемый код не гарантируется правильным. Он может быть функциональным, но даже если он функциональный, это может быть не лучший способ кодирования. Например: я заметил, что когда я попросил его написать компоненты React, он использует общий элемент реквизита и не определяет каждое свойство явно, как это является отраслевым стандартом. Кроме того, он не абстрагирует аналогичный код автоматически в функции, поэтому код обычно слишком многословен.
• НЕ используйте его для генерации кода, который требует много контекста . Если вы надеетесь, что модель сделает вашу работу, у меня для вас плохие новости. Невозможно предоставить модели контекст всей кодовой базы или продукта, поэтому, если у вас еще нет четкого представления о том, как подойти к задаче, ChatGPT реально не очень поможет.
• НЕ используйте его для школьных или университетских заданий . Помимо того, что ответ может быть неверным, а также того, что, возможно, другие студенты будут использовать его с той же целью, ведущей к обнаружению плагиата, вы ничему не научитесь. Решение задач — это то, что заставило меня больше всего расти во время моего формального образования в области разработки программного обеспечения. Не лекция, а задания — это то, чему я научился больше всего, поэтому, если вы обманываете с помощью ChatGPT, вы просто лишаете себя лучшей карьеры.

CodeGPT: расширение VSCode с функциями, подобными ChatGPT

Это расширение позволяет нам использовать GPT-3 внутри VSCode через официальный API OpenAI. Это что-то вроде наличия ChatGPT в нашем редакторе кода!

С CodeGPT мы можем генерировать код, объяснять код, рефакторить код и многое другое. Давайте посмотрим, как его настроить и изучить все его функции.

Настройка CodeGPT на VSCode

Чтобы установить это расширение, нам нужно открыть VSCode, перейти к расширениям и выполнить поиск «Код GPT». Как только мы находим его, мы нажимаем «установить».

После установки кода GPT нам нужно перейти в «Настройки» и перейти к «Код GPT» (в macOS перейдите в строку меню и нажмите «Код», затем выберите «Настройки», чтобы найти параметр «Настройки»).

В настройках мы увидим следующее.

Чтобы работать с этим расширением, вам нужно ввести ключ API OpenAI в первое поле на изображении выше.

Вы можете оставить остальные поля как есть, но если вы хотите их настроить, имейте это в виду:

• Max tokens: Максимальное количество токенов, которое вы хотите получить за каждый запрос к API.
• Model: В настоящее время в этом расширении доступны 3 модели ( text-davinci-003, code-cushman-001и code-davinci-002). Среди этих вариантов code-davinci-002самый мощный, когда дело доходит до кодирования.
• Temperature: контролирует степень случайности в выводе ( чем ниже температура, тем больше вероятность того, что GPT-3 выберет слова с более высокой вероятностью появления ) .

Изучение CodeGPT

Вот основные функции CodeGPT

• Сгенерировать код: вам нужно только ввести комментарий с запросом определенного кода, затем нажать, cmd-shift-iи CodeGPT откроет новое окно с кодом.

• Объяснить код: выберите код, щелкните его правой кнопкой мыши и выберите параметр «Объяснить кодGPT». CodeGPT откроет новое окно и объяснит код.

Вот результат

Для получения дополнительной информации об этом расширении нажмите здесь.

Всем привет. В сети огромное кол-во информации о том, как отшлифовать свои навыки, но мало сказано том, как их успешно применять и продавать в мире, где без связей с людьми подниматься по лестнице гораздо труднее.

Сегодня речь пойдет о социальном взаимодействии в сети и жизни. Я постараюсь дать максимально полезную информацию от себя о:

• Портфолио, продажа себя, социальный капитал
• Поиск единомышленников
• Как находить связи и строить с ними отношения
• Поиск клиентов
• Значимость twitter и его отличие от linkdln
• За что поднимают зарплату? Фокусы для работодателей.
  
  . Ваш username: BenJun.

Для того, чтобы все нижеперечисленное было понятно и усвоилось, давайте сыграем в небольшую игру. Представьте что вы персонаж который только-только приобрел навыки и может претендовать на джуна в блокчейн-разработке

Все что делает игрок, должно заноситься в GitHub. Все ваши проекты в процессе учебы должны быть опубликованы. Ваша задача - собрать из всей своих действий список проектов. Не стоит включать режим самозванца и считать что ваши проекты мусор. Однако, выбрать из них самые стоящие все равно стоит. Пусть они будут в закрепе.

Портфолио, продажа себя

Собирайте о себе как можно больше информации в цифровом формате. Когда на собеседовании вы только-только сядете на стул или подключитесь к комнате в Google Meets перед работодателем будет белый лист. Ваша задача - за короткое время успеть раскрасить себя так, чтобы вас захотели купить. Естественно, рассказать о себе будет недостаточно и вы должны будете кидать на стол свои достижения.
Наилучшая концепция портфолио:
Заполненный GitHub, опыт работы в команде, доказательства участия в сообществе, наличие единомышленников, знакомства с некоторыми локальными лидерами мнений. Переходя к самому собеседованию BenJun'A

Эффектность фактов и скромность поведения вызывает уважение и заинтересованность. Один мой товарищ проходил собеседования держа свое туловище руками. Он создавал образ скромного парня с кучей ментальных проблем, но рассказывая о своих высококвалифицированных прошлых проектах и работе которую он проделывал так, что на работодателей это производило нужный эффект. (Поговорим об этом подробнее в разделе фокусы)
Тщательно подготавливайтесь к собеседованию, чтобы говорить на нем четко.
(О том, как подготовиться к собеседованию я напишу отдельный пост)

Социальный капитал

Социальный капитал показывает, какое влияние вы имеете в социальных кругах. Хорошими показателями для определения социального капитала являются:

• релевантные подписчики на социальных платформах в отрасли
• репутация, сформированная созданием вклада в сеть
• друзья в сети, которые помогут вам расти, у которых вы можете учиться, на которых вы можете положиться, с которыми вы можете обсудить свои идеи и получить от них конструктивную критику.
• связи с людьми, которые могут представить вас или поручиться за вас в различных ситуациях

Существуют различные методы накопления социального капитала. Большинство из них заключается в выводе соответствующего контента, создании сетей и взаимодействии с людьми в сети, создании продуктов, различных способах вклада в экосистему, предоставлении ценности (или развлечения) и многие другие.

Чтобы встретить «хороших» людей в пространстве, вам также нужно проводить свое время в правильных местах и ​​делать правильные вещи, эта статья поможет вам оптимизировать свое внимание и сэкономить время, не тратя его впустую на пустые действия. Вы получите практические советы в следующих разделах.

Еще одним важным аспектом накопления социального капитала является размещение контента, который другие люди находят интересным, привлекательным, актуальным или ценным. Как разработчик в пространстве, ваш контент должен быть ценным для других людей : для разработчиков и других людей, желающих получить более технический обзор области/продуктов/проектов, над которыми вы работаете. Существует также большой потенциал для накопления социального капитала путем создания образовательных ресурсов, таких как подборки, забавные факты, руководства, учебные пособия, обзоры и т.д

Поиск единомышленников

Успешная учеба невозможна без сообщества как и работа. Поиск единомышленников важен в обоих случаях. Вам нужно получать и также обмениваться информацией с людьми чтобы иметь разные точки зрения. Закрывшись дома от всего мира наедине со статьями и кодом обернется либо ментальной трагедией, либо результат будет малоэффективным.
Касательно телеграмма: окунитесь в cообщество с помощью разных чатов, где собираются наставники, стажеры, инвесторы и многие другие люди. В нашей сфере огромное кол-во людей с интересным background'ом, не упускайте эту возможность.
Поймите одну вещь: человеку который имеет знания и занимается определенным делом всегда будет приятно отвечать на вопросы касательно его деятельности. Многим ли людям было бы неприятно если бы у них брали интервью? Я считаю что нет. Не бойтесь спрашивать, когда-то эти люди были такими же как и вы. Спрашивайте, но старайтесь четко формулировать свои вопросы. Однако, не забывайте что у вас под рукой есть Google. Лично я задаю вопросы более опытным ребятам в том случае, если не нахожу информации в поисковике.
Это может быть ошибкой в технической задаче и т.п.

Человеку становится спокойнее, когда он чувствует стабильность. Редко ей можно окружить себя полностью, но касательно социального взаимодействия это возможно. Вам нужна принадлежность к определенной группе людей. В поиске чатов, вы сможете стать участником социальной группы. Приносите вклад в эту соц.группу: делитесь информацией, отвечайте на вопросы на которые знаете ответ, помогайте новым ребятам. Зарабатывая уважение и значимость: вы сможете взаимодействовать с определенными людьми в личных сообщениях. Чем больше у вас будет таких людей, тем больше шанс собрать небольшую команду в будущем. Держите связь.

Окружив себя единомышленниками, BenJun должен найти связи.

Как находить связи и строить с ними отношения

Каждая ситуация с поиском связей является уникальной, поэтому я написал несколько практических советов которые вы можете использовать а так же информацию для общего понимания как работает этот механизм.

Хотя они доступны не всем, но по всему миру проводятся мероприятия, на которых люди из разных сообществ в рамках web3 и криптографии собираются вместе для организации конференций, хакатонов, вечеринок, встреч, переговоров и многого другого. Мероприятия в реальной жизни — одно из лучших мест, где можно найти единомышленников, с которыми можно подружиться, получить работу, пообщаться с другими интересными людьми в этой области, учиться, расширять свои границы и т. д. ,

Недооценено, насколько вы можете вырасти как разработчик, если окружите себя людьми, обладающими теми же качествами, которые вы хотите приобрести для себя. Окружающие вас люди могут подтолкнуть вас к росту и привести к новым высотам, поскольку они ставят перед вами новые задачи и помогают вам на этом пути. Это непредсказуемая штука которая всегда подкидывает сюрпризы, но ваша активность на подобных конференциях определенно даст вам неплохой социальный буст.

Для чего вам нужны связи? Для того чтобы в определенный момент они исполнили вашу просьбу. Но для этого нужно использовать прием, который называется взаимопомощь. Ваша задача помогать человеку, отдавая бескорыстно информацию, помощь с проектами и чем только можно на первых этапах ваших отношений. Для формирования потребности у человека помочь вам с чем-либо нужно время. Однако, это рабочий прием который основан на психологии. Это практический совет, попробуйте и вы ощутите его действие.
Так же вам нужно формировать свою значимость. На самом деле, это внерамочное понятие в этой теме. Ваша задача иметь или получить то, что будет нужно или интересно другим.

Алкоголь позволяет укрепить взаимоотношения. Используйте походы в бар для получения информации, либо повысить свою значимость в глазах человека. В состоянии алкогольного опьянения некоторые рассказанные вами факты, или показанные проекты привлекают внимание и удивляют намного сильнее, чем в трезвом состоянии. Используйте способ с растительным маслом, для того чтобы не потерять связь с реальность. Около двух столовых ложок растительного масла способны создать защитную оболочку в вашем желудке от алкоголя, остается лишь надеть маску пьяного парня.
Помимо алкоголя, такие вещи как совместный обед, стрельба в тире и прочие вещи которые вы можете сделать вдвоем получая одновременно дофамин, способны усилить близость. Если ваша цель определенный человек, все становится немного проще. Ваша задача: при каждой с ним встречи стараться принести как можно больше дофамина в совместное времяпровождение.

Поиск клиентов

Так же я настоятельно рекомендую искать и их на различных конференциях.

Переходя в режим поиска online я скажу лишь то, что вам будет достаточно чатов.
Никакие биржи труда неактуальны для фриланса на первых этапах. Вам нужны конкретные пользователи в сети, желательно не привязанные к большой компании или стартапу. В первое время вам нужно будет добыть себе коммерческое портфолио, и в большинстве случаев, только одиночки вам с этим и помогут. Люди, ищущие исполнителей для себя менее требовательны чем HR-менеджеры из компаний.

Предлагайте и делайте работу для людей с аудиторией в социальных сетях. Когда я был в другой сфере, я предлагал медийным личностям свои услуги за бесплатно, взамен получая ссылки на свои социальные сети которые видели десятки тысяч человек. С этих ссылок я получал огромное кол-во сообщений и 20% из них заканчивались знаком подписания договора - рукопожатием.
Делайте работу качественно, особенно для клиентов с большой аудиторией. Стоит попытаться чтобы после исполнения вашего заказа, вы включили в человеке режим сарафанного радио.
Чем больше о вас узнает людей, тем большее кол-во клиентов вы сможете привлечь. Охотьтесь на аудиторию.

Значимость twitter и его отличие от linkdln

Twitter — это место, где можно найти работу по разработке блокчейна, LinkedIn редко используется для найма талантов в этой области, хотя это тоже не редкость. Поскольку большая часть культуры web3/crypto находится в Твиттере, это естественное место для общения разработчиков, основателей, создателей и пользователей. Чем большую ценность вы предоставляете сообществу, тем больше подписчиков вы получите, а значит, тем больше охват как у разработчика. Все команды жаждут хороших разработчиков, поэтому чем больше у вас будет релевантных подписчиков, тем больше шансов, что вас обнаружит команда, которая хочет нанять разработчика блокчейна в вашей области знаний. Создание вашей репутации в Твиттере может продвинуть вас вперед больше, чем вы ожидаете.

Если вам удастся продемонстрировать мастерство в каком-либо заданном навыке в web3, то вам гарантирована должность практически в любом месте, поскольку все команды ищут таланты. Если вы только начинаете, но проявляете сильное стремление и инициативу в обучении, многие команды попросят взять вас под свое крыло, чтобы улучшить свои навыки, запачкав руки и учась, создавая по ходу дела. Благодаря активности на соответствующих социальных платформах, таких как Twitter, Discord и Telegram, и общению с нужными людьми найти работу становится относительно легко, поскольку все ищут таланты.

Социальные взаимодействия (bonus)

Когда вы находитесь на упомянутых выше социальных платформах, вы должны нацеливаться на людей, которые помогают вам расти, и устанавливать с ними связи.

• эксперты в интересующей вас области

Если вы общаетесь с людьми, обладающими опытом в тех областях, в которых вы хотите стать квалифицированным, вам будет намного легче их изучить, вы получите хорошие связи, которые продвинут вас вперед в вашей карьере, и вы также, скорее всего, получите больше возможностей и ресурсов для роста в качестве разработчика, нанявшись на работу, получив советы о том, как эффективно изучить свою область специализации и многое другое!

• люди пытаются научиться тому же, что и вы

Хорошо делиться идеями и получать двустороннюю обратную связь по любой теме, которую вы изучаете, от других людей, изучающих тот же материал, что и вы, особенно если они более опытны, чем вы. Еще одна веская причина учиться в группах (в идеале в парах) заключается в том, что обучение — это лучший способ закрепить свои знания, поскольку, когда вам нужно просто объяснить сложную тему, вам нужно хорошо понимать любую данную тему, чтобы вы могли объяснить это.

Контент (bonus)

Чтобы накопить социальный капитал, размещение хорошего контента на различных популярных социальных платформах имеет решающее значение, поскольку людям нравится подписываться на отдельных лиц и группы, от которых они могут получить пользу. Например: если вы начнете говорить о создании в DeFi, то люди, заинтересованные в DeFi, начнут подписываться на вас, ставить лайки и ретвитить ваши сообщения, участвовать в обсуждениях в комментариях и т. д. Как разработчик блокчейна в любой специализации, вы можете использовать разные способы. предоставлять интересный контент и распространять его на разных социальных платформах.

• документ > создать в начале Когда вы начинаете работать разработчиком блокчейна, у вас обычно не будет никаких новых открытий, интересных вещей, которые вы создаете, или проектов, над которыми вы работаете, поэтому хорошо поделиться своим собственным процессом обучения и своим путешествием. стать разработчиком блокчейна.
• расскажите о том, что вы узнали в своем путешествии:
  полезно говорить о различных ресурсах, которые вы используете для изучения интересующих вас тем, делиться ими с другими и рассказывать им, как они помогли вам узнать о конкретной теме, а также предоставлять комментарии и полезные советы, которые могут быть упущены людьми, просматривающими ресурсы и не углубляющимися в них.
• говорить об инструментах, которые вы используете: разработчики любят говорить о своих инструментах, какие библиотеки они используют, какие IDE и расширения они используют для написания кода, какие сервисы и приложения они используют ежедневно, чтобы организовать себя и быть продуктивными, и многое другое. более.
• задавайте вопросы о вещах, которые вы изучаете: есть вероятность, что у многих людей, которые следят за вами, задавались те же вопросы, что и у вас в прошлом, и они могут дать вам много полезной информации по любой заданной теме.
• будьте активны в темах, которые имеют отношение к вашим интересам: если в интересующем вас пространстве происходят соответствующие события, рекомендуется участвовать в публичных дискуссиях с другими людьми вокруг этих событий, чтобы получить лучший обзор что происходит, и попытаться извлечь из этого ценную информацию / уроки
• ретвитить то, что происходит в сфере ваших интересов, с комментариями/мнениями
• резюмировать статьи, доклады, события, обновления, обсуждать код в интересующих вас проектах/областях.
• шитпост (выражайте свою индивидуальность / будьте собой) для участия (расширяете свою сеть, развлекаясь): будьте креативны, разработка не обязательно должна быть всем, о чем вы говорите, многие также используют социальные платформы, чтобы подружиться и повеселиться, так что вы также можете делать забавный контент, беззаботные темы на любую заданную тему, публиковать фотографии вашей собаки или что угодно. Выражение собственной индивидуальности также полезно для создания личного бренда в социальных сетях.

За что поднимают зарплату? Фокусы для работодателей.

В сети куча людей бесконечно твердит что уровень вашей заработной платы напрямую зависит от качества вашей работы, статичных приложенных усилий за рабочие дни, и многое другое характеризующиеся неким "плодом состояния потока", но в реальной жизни это выглядит немного иначе.

Безусловно выполнять свою работу качественно и ставить перед собой цели чуть выше ваших реальных возможностей ведет вас наверх и необходимо для развития. Это так же может влиять на заработную плату, но если вы грамотно будете показывать это работодателю.

Сегодня я зайду в эту тему немного с иной стороны, и о том как ваша продуктивность отражается на заработную плату говорить не стану. Довольно мейнстрима. Ибо все это на самом деле малоэффективно если вы работаете на кого-либо. Продуктивность и все вышенаписанное стоит применять когда вы работаете на себя. А знаете что на самом деле эффективно? Фокусы.

Начну с примера из реальной жизни. Пусть его имя будет так же - BenJun.
BenJun работает в сфере кибербеза и считается квалифицированных специалистом, но почему-то его зарплата не переваливает больше чем за 75тыс рублей. Почему так? Разбирая тему подробнее, давайте подумаем кто ему платит деньги и что из себя представляет этот человек?
BenJun получает деньги от человека, который знаком с кибербезом достаточно поверхностно. Его задача - находить клиентов и эксплуатировать BenJun'а.
Несколько месяцев подряд BenJun активно пытался работать очень искусно, делая необычные вещи и крайне гениальные проекты. Однако, все эти гениальности проявлялись в мелочах, и знаете, для высококвалифицированного специалиста эта самая гениальность выглядит иначе, чем для обычного начальника который не посвящает этой деятельности все свободное время. Планка того, что гениально у специалиста выше, чем у обычного человека. (так в любой сфере) Следовательно, получается так, что BenJun делает поистине гениальные мелочи, но начальник слишком поверхностен в этой деятельности чтобы их понять. И после выплеска всей своей креативности и энергии BenJun остается с той же самой зарплатой. Однако к нему в штат приходит новый сотрудник который на несколько лет меньше в этой сфере, но уже через два месяца его заработная плата дошла до 100 тысяч рублей в месяц. Что он сделал?
В один из дней сотрудник вставил флешку в ноутбук своего начальника и удаленно выводил на его экране: калькулятор, текстовый документ и другие приложения. Начальник не понимал что происходит, но после всего этого сотрудник подходил к нему и объяснял что произошло. Таких мелочей в его днях становилось больше, и зарплата росла.

А теперь давайте разберем этот механизм:

Фокус заключался в том, что сотрудник делал простые, но эффектные вещи. Эффектных в сознании начальника. Так уж устроен наш мир, но работает это действительно так, как бы вас это не забавляло.
Психология и фокусы способны вести вас вверх с бешеной скоростью, в любой сфере в которой вы начинаете работать.
Однако не всегда это работает везде и всегда. Сначала стоит проанализировать действительно ли ваш начальник как в примере выше. Исключения бывают реже, чем такой подход с фокусами. Именно в этих исключениях вы и сможете плодить свои гениальные проекты, однако, если вы действительно способны кодить подобное, стоит работать на себя. Люди будут лишь продавать ваш товар.

Возвращаемся к теме.

Вывод таков, что эффектность и фокусы действуют на работодателей "магическим" образом. Опять же, как я уже и говорил в разделе про поиск связей: впечатление. К сожалению, в нашей жизни это действительно рабочий метод. И он является эффективным в большинстве сфер.

«Единственная перспектива у продвинутого парня в этой стране — работать клоуном у пидарасов. А кто не хочет работать клоуном у пидорасов, будет работать пидорасом у клоунов. За тот же самый мелкий прайс» - В. Пелевин

Вы так же должны выполнять свою работу качественно, но поймите одну вещь: Поднятие вашей заработной платы будет зависеть в большинстве от фокусов, нежели от профессионально выполненной рутины.

GAME OVER
Winner's nickname: BenJun

Надеюсь что я дал вам полезную информацию которую вы сможете применить в своей жизни, либо которая изменит ваше представление или мышление по поводу некоторых вещей. Если вам интересен подобный материал, вы можете поддержать меня в моем телеграмм канале https://t.me/Solidity_RUS_ETH

Раньше новости почти полностью относились к вещательным и печатным источникам новостей, но теперь примерно 62% пользователей получают новости из социальных сетей и других источников новостей в Интернете.

Многие люди принимают все, происходящее в интернете, за реальную картину мира. Однако алгоритмы поисковых сетей настроены таким образом, что создают «информационный пузырь» вокруг каждого пользователя. Как это делается? Очень просто.

Браузер анализирует предпочтения и личные данные человека и выдает ему соответствующие рекомендации. Например, подсовывает, как кажется системе, интересные человеку видеоролики, статьи или посты в соцсетях.

Каждый «лайк» и комментарий анализируется и вносится в алгоритм. С очередным обновлением система корректирует информационную ленту с учетом предпочтений.

Причем, если не ставить лайки и не писать комментарии, программа считывает время просмотра того или иного материала. Бывает, что одну инфу пролистываешь, а другую внимательно изучаешь, а что-то и вовсе скачиваешь или добавляешь в закладки.

Мир стремительно меняется и поток информации увеличивается с каждым днем. В каждой стране система агитации и пропаганды не всегда может своевременно справится с потоком информации и адекватно на него отреагировать.

Любая государственная система – штука довольно неповоротливая и любая вещь проходит многочисленные этапы согласований. Поэтому зачастую люди не получают четкого ответа и ищут информацию в Сети. А там их ждут всезнающие алгоритмы поисковых сетей, которые подскажут что почитать/посмотреть/послушать.Каждый «лайк» и комментарий анализируется и вносится в алгоритм. С очередным обновлением система корректирует информационную ленту с учетом предпочтений.

Следовательно для некоторых, этой банальной информации, я предоставлю решение выхода из "матрицы".

Несколько дней назад я нашёл крайне амбициозный поисковик metaphor:

https://metaphor.systems/

Его ранжирование не основано на коммерции. Первые страницы что он выдаст вам по запросу, не проплачены и не выданы благодаря алгоритмам "чтобы прочитал именно это". Он основан он на алгоритме "выдать самое подходящее" Вы сами можете сравнить ранжирование попробовав задать вопрос в Google, Yandex и затем в Metaphor. Например: Кто такой Сноуден?

Вполне вероятно, что Google и Yandex на первую строку выкинет вам википедию, в отличии от того же самого Metaphor. На первых строках нет банального wiki, а так же куча сайтов на первой строке с более подходящими ответами которые гугл почему-то не показывает.

Свободу искателям информации!

Различный опыт развивает человека с разной скоростью. Вы можете всю жизнь работать на скучной работе и в 60 лет быть не намного круче среднего подростка. С другой стороны, у некоторых людей настолько разнообразный и богатый жизненный опыт, что к 30 годам они становятся такими же потрясающими, как 1000-летний вампир.

Это напоминает мне о том, что можно провести свою жизнь с большей или меньшей эффективностью, иногда на порядки. Кроме того, хотя у нас нет реального продления жизни, нам важно содержание, а не время работы. Если вы можете изменить свои привычки так, чтобы успевать делать в 3 раза больше, это все равно, что втрое увеличить эффективную продолжительность жизни.

Так как же можно добиться 100-кратного ускорения и за 10 лет стать 1000-летним вампиром? Это абсурдно амбициозно, но мы можем попробовать:

Делайте трудные вещи
Некоторые события способствуют вашему личностному развитию. Вы можете систематически накапливать их, чтобы как можно быстрее стать грозным.

Пол Грэм говорит, что многие из основателей, которых он видит (как глава YC), очень быстро становятся более потрясающими, поскольку их заставляет нужда. Это кажется правдоподобным и подтверждается другими источниками. По сути, "научись плавать, прыгнув в глубокую воду"; люди склонны выбирать легкий путь, который приводит к меньшему развитию, когда им предоставляется шанс, поэтому возможность отстраниться может быть полезной.

Это был и опыт моего товарища. На его работе главный инженер заболел раком мозга, и его де-факто повысили до руководителя двух проектов, которые он затем выровнял, чтобы быть в состоянии выполнять. Поначалу это было довольно страшно, но теперь ему скучно и хочется чего-то еще, что бросило бы вызов. (добавление: сейчас ему совсем не скучно; у другой команды, которой он помогает, сумасшедшее время кризиса) Кажется, очень трудно просто делать лучше без такого принуждения; насколько я могу судить, он мог бы работать гораздо усерднее, чем сейчас, но силы воли, по сути, не существует, поэтому он этого не делает.

В связи с этим, еще один парень добился больших результатов после службы в армии и попадания под действие слезоточивого газа в окопе, когда он был мокрым, холодным, измученным, лишенным сна и голодным, что заставило его пройти через такие испытания, о которых он и не думал. Очевидно, это в какой-то степени перекалибровало его представления о том, насколько хорошо он должен жить и насколько все тяжело, так что теперь он миллионер и просто супер.Privet)

Так что механизм, стоящий за многим из этого, похоже, заключается в перекалибровке того, что кажется трудным, пугающим или выходящим за пределы вашей обычной сферы. Раньше я боялся телефонных звонков и таких странных вещей, как танцевать на улице в присутствии незнакомых людей, но теперь не так сильно; кажется, что я просто забыл, что это было страшно. В случае с телефоном было несколько случаев, когда у меня не было времени бояться, мне нужно было просто сделать дело. В случае с танцем, я делал это самостоятельно настолько, что это стало нормой, так что даже не возникало мысли о том, что люди увидят меня, потому что это не казалось странным.

Так что, если связать это воедино, есть опыт, которому вы можете подвергнуть себя, чтобы заставить нормализоваться и акклиматизироваться к трудным вещам. Например, некоторые люди занимаются тем, что называют "терапией отторжения" или "расширением зоны комфорта", по сути, выходят на улицу и специально делают неловкие или пугающие вещи, чтобы перекалибровать свою интуицию и научить свой мозг, что они не так уж и страшны.

Что касается неудач, то проекты по самосовершенствованию обычно терпят неудачу, если они требуют постоянного приложения силы воли. Это просто факт, что в таких случаях вы будете сбиваться с пути. Поэтому вы должны сделать так, чтобы сбиться с пути было невозможно. Вы должны сделать так, чтобы выпасть из вагона было страшнее, чем подняться на уровень выше и просто сделать это. Именно эта идея лежит в основе Beeminder, который забирает ваши деньги, если вы не делаете то, что обещали себе на прошлой неделе. (dont use Beeminder :) )

Я полагаю, что тезис всего этого заключается в том, что эти повышения уровня постоянны, поскольку они делают вас более похожим на 1000-летнего вампира, и вы не можете просто вернуться к своему старому скучному смертному. Если это правда, то вывод о том, что вы должны искать сложные вещи, кажется довольно интересным и важным.

Широта опыта

Подумайте о 1000-летнем вампирах; они должны были делать все. Сражались в битвах, руководили армиями, строили великие произведения, были влюблены, были везде, наблюдали большинство аспектов человеческого опыта и вообще видели все.

Вещи, которые вы можете делать, имеют резко убывающую отдачу; первые несколько раз, когда вы смотрите великие фильмы, приносят большую часть пользы, то же самое с видеоиграми, 4chan, большинством работ и большинством опыта в целом. Поэтому очень важно менять те вещи, которые вы делаете часто, чтобы оставаться в той острой, первоначально растущей части кривой обучения. Вы можете получить 90% опыта вампира, затратив 10% его времени, если сосредоточитесь на наиболее познавательных частях каждого опыта.

Таким образом, помимо выполнения сложных заданий, которые повышают ваш уровень, вы можете добиться больших успехов, выполняя множество заданий и меняя их, как только вам надоест (что, надеюсь, будет выверено в соответствии с вашим уровнем сложности).

В начале арабской революции в Ливии один американский студент взял летний отпуск в колледже, чтобы участвовать в революции. Уверен, он многому научился. Если бы вы могли сделать достаточно таких вещей, вы бы уже были на пути к тому, чтобы соответствовать вампиру.

Это на самом деле идет рука об руку с выполнением трудных дел; когда вы не чувствуете вызова (вы находитесь на плоской части этой кривой опыта), вероятно, лучше всего броситься с головой в какой-нибудь новый проект, и потому что он новый, и потому что он трудный.

Переключение часто имеет дополнительное преимущество в нормализации стратегических изменений и тренировке мыслей типа "что я должен делать", что не повредит, если вы намерены действительно делать полезные вещи в своей жизни.

Вероятно, есть много случаев, когда полное переключение не является оптимальным. Например, вы не станете экспертом в Х, если переключитесь с Х сразу после того, как узнаете основы. Возможно, вы хотите часто переключаться на побочные вещи, но глубоко погрузиться в X. Или же вы, вероятно, хотите время от времени переключаться на X, возможно, посмотреть на вещи с другой точки зрения, решить другую проблему или что-то в этом роде. This is есть теория преднамеренной практики в экспертизе.

Не забывайте о форме кривой опыта. Как только вы начинаете чувствовать, что она выравнивается, найдите способ сделать ее снова свежей.

Делайте вещи быстро

Другой важный аспект этой идеи заключается в том, что каждый час - это возможность, и вы хотите использовать ее наилучшим образом. Это кажется совершенно очевидным, но я понял это гораздо лучше, подумав о том, как стать 1000-летним вампиром.

Большой пример - промедление. У меня есть много дел, которые уже долгое время висят в моем списке дел, по сути, угнетая меня своим присутствием. Я не могу расслабиться и заняться новыми делами, пока в моем списке все еще остается одно дурацкое дело. Ключевой момент заключается в том, что если вы обрабатываете дела в списке дел сейчас, вместо того чтобы халтурить и делать их позже, вы убираете их с дороги и можете заняться чем-то другим позже, и таким образом быстрее становитесь вампиром.

Поэтому мы с другом немного углубились в эту тему и начали замечать эти альтернативные издержки, и действительно стали выполнять дела быстрее. Я уверен, что это еще не все; мы еще не достигли оптимального уровня в "Делать это сейчас", так что, возможно, стоит поразмышлять над этим еще.

В качестве конкретного примера: я пишу сегодня, потому что понял, что мне нужно просто убрать все свои писательские идеи с дороги, чтобы освободить место для еще большего великолепия.

Обратная сторона этой идеи заключается в том, что многие вещи являются пустой тратой времени, в том смысле, что они просто сжигают время жизни и ничего вам не дают, или даже ослабляют вас. Следовательно для того, чтобы не терять времени анализируйте с разных сторон то, за что собираетесь браться.

Такие вредные привычки, как чтение всякой ерунды в Интернете (серфинг), просмотр телевизора, порнографии, видеоигры, недосыпание и так далее, - это очевидные потери. Это очень трудно усвоить, но концепция 1000-летнего вампира помогла мне осознать величину затрат. Хотите ли вы проснуться в 30 лет и понять, что потратили свою молодость на бессмысленное дерьмо, или вы хотите оторвать свою задницу и написать то, что вы хотели написать прямо сейчас, и стать чертовым вампиром через 10 лет?

Но дело не только во вредных привычках; многое зависит от вашего более широкого положения в жизни, которое заставляет или не заставляет вас тратить время. Например, повторяющаяся работа за зарплату, которая не бросает вам вызов, - это просто торговля огромным куском своей жизни за не очень большие деньги. Конечно, иногда приходится работать, но вы должны понимать, что отдать половину своей жизни - это довольно грубая сделка, которой следует избегать. Вы даже не получаете ничего за проезд на работу и работу по дому. Поймите одну вещь: многим людям платят гроши за то, что они отдают в рабство себя и свое время . Поставьте себе цель выбраться из порочного круга и сделать так, чтобы вам платили не за ваше время, а за ваши навыки. Стремитесь к тому, чтобы ваша минута стоила намного больше, чем зарплата сотрудников KFC в месяц. Вы должны стать уникальным во многих вещах, придерживаться своей идеологии и уметь делать что-то крутое, что сможет сделать небольшое количество людей. Чем полезнее и профессиональнее ваши навыки, тем дороже вы сможете продать минуту своего времени.

У меня 168 часов в неделю, из которых только 110 можно использовать (сон), а если учесть все домашние дела, работу за зарплату, вредные привычки и промедление, то я, вероятно, живу только 30 часов в неделю. Это полный бред; три четверти моей жизни выброшены на ветер. Я мог бы прожить в четыре раза больше, если бы смог избавиться от этих вещей.

Так что это просто концепция альтернативных затрат времени, облеченная в более рельефную форму. Базовые экономические концепции кажутся очень ценными в этом смысле.

Сделай это сейчас, чтобы потом заняться чем-то другим. Избегайте дерьмовой работы.

Социальная среда и стимуляция

Я замечаю, что я наиболее оживлен и выполняю свою лучшую интеллектуальную работу, когда общаюсь с другими людьми, которые умны и заинтересованы в глубоких технических беседах.

(Скоро откроются двери в наш будущий SPACE на квартире)

Другие вещи, такие как определенные модели давления времени, создают этот эффект, когда я работаю во много раз интенсивнее и эффективнее, чем в противном случае. Отличным примером являются технические экзамены; я могу быстро ответить на сотни технических вопросов.

Кажется, что это хорошая идея - вызвать это состояние, когда вы более живы (это состояние "потока"?), если вы хотите прожить больше жизни. Также кажется вполне возможным делать это чаще, общаясь с правильными людьми и подвергая себя правильным условиям работы и тому подобное.

Одна вещь, которая всплывает, это то, что это довольно истощает, в том смысле, что я иногда чувствую себя измотанным и не могу многого добиться после дня более интенсивной работы. Так ли это на самом деле? Возможно. Тем не менее, я не приблизился к пределу, даже учитывая необходимость отдыха, в целом.

Я должен провести исследование, чтобы узнать об этом больше. Если это связано с "потоком", то было много исследований, AFAIK.

Мне также следует поторопиться и переехать в страну, где есть подходящее интеллектуальное сообщество, которое будет стимулировать меня гораздо лучше, чем та скудная группа мозгов, которую я смог собрать на данный момент после отлетов моих старых друзей в Европу после войны. Тех, с кем были идеально сплетены языки. Хотя, я нахожусь в поиске мозгов в этой стране до сих пор. Возможно, что в ближайшее время у меня все таки получится создать сообщество вампиров в России.

Другое преимущество хорошего интеллектуального сообщества в том, что оно может стимулировать делать более крутые вещи. Когда все ваши друзья открывают компании или занимаются чем-то другим, сидеть на диване кажется очень плохой идеей.

Поэтому, если мы хотим прожить больше жизни, найти больше способов войти в состояние стимулированного потока кажется разумным решением, будь то создание условий для этого в ваших рабочих привычках, помещение себя в более сложную социальную и интеллектуальную среду или что-то еще.

Суммирование

Итак, как быстро мы можем достичь общего результата, если будем делать все это?

Если стремиться к получению нового опыта, чтобы продолжать учиться, я думаю, можно добиться 10-кратного ускорения по сравнению с тем, что вы можете делать по умолчанию. Очевидно, что это может быть больше или меньше, в зависимости от обстоятельств и вещей, которые вы не предскажете.

Кроме того, мне кажется, что я могу сделать в 4 раза больше, если буду поддерживать привычку делать это сейчас и избегать некачественной работы. Как это сделать, я пока не знаю, но это возможно.

Я не знаю, как оценить реальный выигрыш от стимулирующей среды. Кажется, что он может быть действительно очень высоким, или просто еще один прирост эффективности, в зависимости от того, как это происходит. Допустим, в дополнение ко всему прочему, мы можем реально подтолкнуть себя в 2 или 3 раза сильнее за счет социальных и экологических эффектов.

Делать трудные вещи кажется огромной задачей, но в то же время она связана с тем, что мы уже учли, делая новые вещи. Значит, явно помнить о необходимости делать трудные вещи в дополнение к этому? Может быть, в 5 раз? Это опять же будет сильно варьироваться в зависимости от того, какие возможности вы сможете найти, и от неизвестных факторов, но 5x кажется достаточно безопасным, учитывая смертный уровень изобретательности и силы воли.

Итак, все вместе: тот, кто:

1. Часто задумывается о том, на каком этапе кривой опыта он находится, и принимает соответствующие меры,
2. Поддерживает привычку делать что-то сейчас и визуализирует эти альтернативные затраты,
3. Помещает себя в стимулирующую среду, такую как интеллектуальное сообщество , и окружает себя стимулирующими людьми и событиями,
4. Стремится получить самый тяжелый опыт для становления характера, например, попасть под действие слезоточивого газа в окопе или построить компанию с нуля

Может получить 500-кратное ускорение и прожить 1000 нормальных лет за 2. Это кажется довольно диким, но ни одна из этих вещей не является чем-то необычным, и такие люди, как Илон Маск или Элиэзер Юдковски, похоже, делают примерно на такую же величину больше, чем среднестатистический.... (Внимание! Русский M@T)

Возможно, они не так легко ускоряются, или есть какая-то другая загвоздка, но цель кажется достижимой, и эти вещи помогут. С другой стороны, они почти наверняка самоподкрепляются ; 1000-летний вампир овладел бы искусством проживать жизнь со все более высокой эффективностью.

Это, кажется, согласуется с тем, что все эти вещи распределены по закону мощности, что, конечно, затрудняет их обобщение одним числом, таким как 500.

Последний вопрос, конечно, заключается в том, какого реального ускорения мы можем ожидать от вас или от меня в результате прочтения этой статьи. Получение более чем 2-3-кратного ускорения от низкоуровневого понимания или прочтения статьи в блоге кажется просто поразительным, не говоря уже о 500-кратном. Но, тем не менее, законы силы имеют место.

Вероятно, у вас будет огромная отдача от того, что вы отнесетесь к этой идее серьезно.

#Parkinson
#Бункер

Краткий обзор учетной записи и адреса в Ethereum:

В Ethereum существует два типа учетных записей: внешняя учетная запись (EOA) и контрактная учетная запись. Оба типа учетных записей имеют связанный с ними адрес. Адрес в Ethereum — это 42-символьный шестнадцатеричный адрес.

Например, адрес смарт-контракта UniswapV3Factory Uniswap — 0x1F98431c8aD98523631AE4a59f267346ea31F984 , и он одинаков в основной сети Ethereum, Polygon, Optimism, Arbitrum и Avalanche. То же самое относится ко всем смарт-контрактам Uniswap.

Как генерируется адрес смарт-контракта?

Адрес смарт-контракта получается из двух значений: адреса пользователя EOA и количества транзакций, отправленных пользователем. Это адрес кошелька пользователя и одноразовый номер.

Учебник по Nonce. Проще говоря, Nonce — это количество транзакций, которые пользователь совершил в данной цепочке блоков. Каждый раз, когда у пользователя есть исходящая транзакция, одноразовый номер увеличивается на единицу. Одноразовый номер уникален для каждого блокчейна, а это означает, что отправка транзакции в Ethereum увеличит одноразовый номер учетной записи в Ethereum, но не в Polygon.

Обратите внимание, что мы имеем в виду одноразовый номер учетной записи, относящийся к пользователю, а не одноразовый номер блока.

Как я упоминал в начале статьи, адрес смарт-контракта является детерминированным. Мы можем определить адрес до фактического развертывания смарт-контракта, используя адрес кошелька, с которого пользователь будет развертывать контракт, и их самый последний одноразовый номер + 1.

Ниже приведен пример кода, использующего ether.js для вычисления адреса перед развертыванием. Проверьте вывод

const walletAddress = "0xBf7504799c6ED34dbC7D3077e3198f1F5D2B1306"; const nonce = 0; let deployedAddress = ethers.utils.getAddress(ethers.utils.getContractAddress({from: walletAddress, nonce})); console.log(deployedAddress); //Console will print 0x488f7dab2688771f8d8308b2e65a0977d1b06e51 //verify via Polyscan https://mumbai.polygonscan.com/tx/0x84760a4617c32d2acd90c2c9baf465abbb72a64e26420585a0eca299eea9efef

Наконец, чтобы ответить на вопрос: «Как развернуть смарт-контракт на один и тот же адрес в разных блокчейнах?» ——>——>——>

В нашем кошельке я использую Metamask, мы должны сохранить учетную запись, назовем ее учетной записью развертывания, только для развертывания смарт-контрактов. Мы не должны совершать в нем никаких транзакций, кроме создания смарт-контракта. Отправка транзакций создания смарт-контрактов во всех блокчейнах с одним и тем же одноразовым номером приведет к тому, что везде будет использоваться один и тот же адрес смарт-контракта.

Тот же адрес делает смарт-контракт более удобным для разработчиков. Это уменьшает трение при поддержании адресов для разных окружений (основная сеть и тестовая сеть) и блокчейнов (Эфириум, Полигон и т. д.). Это также упрощает социализацию запуска.