ethereum posts - idmontie's Portfolio

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    h2: "h2",
    strong: "strong",
    a: "a",
    pre: "pre",
    code: "code"
  }, props.components);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "The crypto craze has died down, but if you are working on Smart Contracts or thinking about creating a new blockchain projects, security is a huge part of making sure the project is successful. Since Smart Contracts often interact with cryptocurrencies, blockchain assets, or other tokens, it’s important to make sure the Smart Contract is secure and follows best practices."
    }), "\n", _jsx(_components.p, {
      children: "In general, the best practices around Smart Contracts are the same for writing secure code in general."
    }), "\n", _jsx(_components.h2, {
      children: "Keep it Simple"
    }), "\n", _jsx(_components.p, {
      children: "Keep your Smart Contract code simple. Smart Contracts that try to be too clever often have unintended side-effects or functionality. Keeping a Smart Contract simple also means that the surface area for attacks is smaller."
    }), "\n", _jsx(_components.h2, {
      children: "Write Small Functions"
    }), "\n", _jsx(_components.p, {
      children: "Write small functions that do one thing. Many Smart Contracts will have many small functions that can be composed together, rather than one large function that does everything. This helps keep the code readable, making it easier to understand and secure."
    }), "\n", _jsx(_components.h2, {
      children: "Linting"
    }), "\n", _jsx(_components.p, {
      children: "Lint your code. Smart Contracts written in Solidity have tools already written that can help catch common errors via linting. The easiest linters to set up just help improve formatting, but some can help you write more secure code by letting your know when functions have been deprecated or marked as insecure."
    }), "\n", _jsx(_components.h2, {
      children: "Unit Tests"
    }), "\n", _jsxs(_components.p, {
      children: ["Unit test your code. The best unit tests you can write for Smart Contracts are validating what users shouldn’t be able to do. As an example, make sure unauthorized accounts cannot withdraw assets from your contract. These are sometimes called ", _jsx(_components.strong, {
        children: "negative"
      }), " tests and they can be even more important than your typical that validate your functions do what you expect them to do. These tests check that they fail in the correct way when misused."]
    }), "\n", _jsx(_components.h2, {
      children: "Scan for Security Vulnerabilities"
    }), "\n", _jsx(_components.p, {
      children: "Scan your code for security vulnerabilities. This is pretty self-explanatory. Many Smart Contract toolchains provide scanning tools to check your Smart Contract code."
    }), "\n", _jsxs(_components.p, {
      children: ["There are a few ways to surface security issues in Ethereum Smart Contracts. One way is to use ", _jsx(_components.a, {
        href: "https://github.com/crytic/slither",
        children: "slither"
      }), ":"]
    }), "\n", _jsx(_components.pre, {
      children: _jsx(_components.code, {
        className: "language-tsx",
        children: "npm install slither\nslither .\n"
      })
    }), "\n", _jsx(_components.p, {
      children: "This may take a while to run, but it will scan the compiles contracts for security issues."
    }), "\n", _jsx(_components.h2, {
      children: "Compliance"
    }), "\n", _jsxs(_components.p, {
      children: ["For Ethereum Smart Contracts, you can also use ", _jsx(_components.a, {
        href: "https://github.com/crytic/slither",
        children: "slither"
      }), " to check the compliance of your ERC20 token or ERC721 contracts. Running this check will verify that your contract implements the expected interfaces of the given contracts."]
    }), "\n", _jsx(_components.h2, {
      children: "Wrapping it Up"
    }), "\n", _jsx(_components.p, {
      children: "Security is a major consideration in any application, but Smart Contracts pose a new type of attack vector for malicious users. Smart Contracts often interact with pools of cryptocurrency, NFTs, and other blockchain assets that make them new targets for attackers. It’s important when writing Smart Contracts to always make sure the contract fails correctly, even more-so than completing actions successfully."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};


<p>The crypto craze has died down, but if you are working on Smart Contracts or thinking about creating a new blockchain projects, security is a huge part of making sure the project is successful. Since Smart Contracts often interact with cryptocurrencies, blockchain assets, or other tokens, it’s important to make sure the Smart Contract is secure and follows best practices.</p>
<p>In general, the best practices around Smart Contracts are the same for writing secure code in general.</p>
<h2>Keep it Simple</h2>
<p>Keep your Smart Contract code simple. Smart Contracts that try to be too clever often have unintended side-effects or functionality. Keeping a Smart Contract simple also means that the surface area for attacks is smaller.</p>
<h2>Write Small Functions</h2>
<p>Write small functions that do one thing. Many Smart Contracts will have many small functions that can be composed together, rather than one large function that does everything. This helps keep the code readable, making it easier to understand and secure.</p>
<h2>Linting</h2>
<p>Lint your code. Smart Contracts written in Solidity have tools already written that can help catch common errors via linting. The easiest linters to set up just help improve formatting, but some can help you write more secure code by letting your know when functions have been deprecated or marked as insecure.</p>
<h2>Unit Tests</h2>
<p>Unit test your code. The best unit tests you can write for Smart Contracts are validating what users shouldn’t be able to do. As an example, make sure unauthorized accounts cannot withdraw assets from your contract. These are sometimes called <strong>negative</strong> tests and they can be even more important than your typical that validate your functions do what you expect them to do. These tests check that they fail in the correct way when misused.</p>
<h2>Scan for Security Vulnerabilities</h2>
<p>Scan your code for security vulnerabilities. This is pretty self-explanatory. Many Smart Contract toolchains provide scanning tools to check your Smart Contract code.</p>
<p>There are a few ways to surface security issues in Ethereum Smart Contracts. One way is to use <a href="https://github.com/crytic/slither">slither</a>:</p>
<div class="overflow-auto rounded bg-gray-200 p-4 font-mono text-sm dark:bg-gray-800 dark:text-gray-100"><pre><code class="language-tsx">npm install slither
slither .
</code></pre></div>
<p>This may take a while to run, but it will scan the compiles contracts for security issues.</p>
<h2>Compliance</h2>
<p>For Ethereum Smart Contracts, you can also use <a href="https://github.com/crytic/slither">slither</a> to check the compliance of your ERC20 token or ERC721 contracts. Running this check will verify that your contract implements the expected interfaces of the given contracts.</p>
<h2>Wrapping it Up</h2>
<p>Security is a major consideration in any application, but Smart Contracts pose a new type of attack vector for malicious users. Smart Contracts often interact with pools of cryptocurrency, NFTs, and other blockchain assets that make them new targets for attackers. It’s important when writing Smart Contracts to always make sure the contract fails correctly, even more-so than completing actions successfully.</p>


The crypto craze has died down, but if you are working on Smart Contracts or thinking about creating a new blockchain projects, security is a huge part of making sure the project is successful. Since Smart Contracts often interact with cryptocurrencies, blockchain assets, or other tokens, it’s important to make sure the Smart Contract is secure and follows best practices.

In general, the best practices around Smart Contracts are the same for writing secure code in general.

## Keep it Simple

Keep your Smart Contract code simple. Smart Contracts that try to be too clever often have unintended side-effects or functionality. Keeping a Smart Contract simple also means that the surface area for attacks is smaller.

## Write Small Functions

Write small functions that do one thing. Many Smart Contracts will have many small functions that can be composed together, rather than one large function that does everything. This helps keep the code readable, making it easier to understand and secure.

## Linting

Lint your code. Smart Contracts written in Solidity have tools already written that can help catch common errors via linting. The easiest linters to set up just help improve formatting, but some can help you write more secure code by letting your know when functions have been deprecated or marked as insecure.

## Unit Tests

Unit test your code. The best unit tests you can write for Smart Contracts are validating what users shouldn’t be able to do. As an example, make sure unauthorized accounts cannot withdraw assets from your contract. These are sometimes called **negative** tests and they can be even more important than your typical that validate your functions do what you expect them to do. These tests check that they fail in the correct way when misused.

## Scan for Security Vulnerabilities

Scan your code for security vulnerabilities. This is pretty self-explanatory. Many Smart Contract toolchains provide scanning tools to check your Smart Contract code.

There are a few ways to surface security issues in Ethereum Smart Contracts. One way is to use [slither](https://github.com/crytic/slither):

```tsx
npm install slither
slither .
```

This may take a while to run, but it will scan the compiles contracts for security issues.

## Compliance

For Ethereum Smart Contracts, you can also use [slither](https://github.com/crytic/slither) to check the compliance of your ERC20 token or ERC721 contracts. Running this check will verify that your contract implements the expected interfaces of the given contracts.

## Wrapping it Up

Security is a major consideration in any application, but Smart Contracts pose a new type of attack vector for malicious users. Smart Contracts often interact with pools of cryptocurrency, NFTs, and other blockchain assets that make them new targets for attackers. It’s important when writing Smart Contracts to always make sure the contract fails correctly, even more-so than completing actions successfully.


Smart Contract Security