help.tpwallet.io

[abrahem79]

`pragma solidity ^0.4.18;

import './SafeMath.sol';

/**

• @title ERC20Basic
• @dev Simpler version of ERC20 interface
• @dev see ERC: Simpler Token Standard ethereum/EIPs#179
  */
  contract ERC20Basic {
  function totalSupply() public constant returns (uint);
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
  }

/**

• @title Basic token
• @dev Basic version of StandardToken, with no allowances.
  */
  contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

mapping(address => uint256) balances;

/**

• @dev transfer token for a specified address

• @param _to The address to transfer to.

• @param _value The amount to be transferred.
  */
  function transfer(address _to, uint256 _value) public returns (bool) {
  require(_to != address(0));
  require(_value <= balances[msg.sender]);

  // SafeMath.sub will throw if there is not enough balance.
  balances[msg.sender] = balances[msg.sender].sub(_value);
  balances[_to] = balances[_to].add(_value);
  Transfer(msg.sender, _to, _value);
  return true;
  }

/**

• @dev Gets the balance of the specified address.
• @param _owner The address to query the the balance of.
• @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) public view returns (uint256 balance) {
  return balances[_owner];
  }

}
pragma solidity ^0.4.4;
/* solhint-disable var-name-mixedcase */

contract Migrations {
address public owner;
uint public last_completed_migration;

modifier restricted() {
    if (msg.sender == owner) _;
}

function Migrations() public {
    owner = msg.sender;
}

function setCompleted(uint completed) public restricted {
    last_completed_migration = completed;
}

function upgrade(address newAddress) public restricted {
    Migrations upgraded = Migrations(newAddress);
    upgraded.setCompleted(last_completed_migration);
}

}
pragma solidity ^0.4.10;

/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - stefan.george@consensys.net
contract MultiSigWallet {

uint constant public MAX_OWNER_COUNT = 50;

event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);

mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;

struct Transaction {
    address destination;
    uint value;
    bytes data;
    bool executed;
}

modifier onlyWallet() {
    if (msg.sender != address(this))
        throw;
    _;
}

modifier ownerDoesNotExist(address owner) {
    if (isOwner[owner])
        throw;
    _;
}

modifier ownerExists(address owner) {
    if (!isOwner[owner])
        throw;
    _;
}

modifier transactionExists(uint transactionId) {
    if (transactions[transactionId].destination == 0)
        throw;
    _;
}

modifier confirmed(uint transactionId, address owner) {
    if (!confirmations[transactionId][owner])
        throw;
    _;
}

modifier notConfirmed(uint transactionId, address owner) {
    if (confirmations[transactionId][owner])
        throw;
    _;
}

modifier notExecuted(uint transactionId) {
    if (transactions[transactionId].executed)
        throw;
    _;
}

modifier notNull(address _address) {
    if (_address == 0)
        throw;
    _;
}

modifier validRequirement(uint ownerCount, uint _required) {
    if (   ownerCount > MAX_OWNER_COUNT
        || _required > ownerCount
        || _required == 0
        || ownerCount == 0)
        throw;
    _;
}

/// @dev Fallback function allows to deposit ether.
function()
    payable
{
    if (msg.value > 0)
        Deposit(msg.sender, msg.value);
}

/*
 * Public functions
 */
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
    public

`

[abrahem79]

const { createServer } = require('node:http');

const hostname = '127.0.0.1';
const port = 3000;

const server = createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello World');
});

server.listen(port, hostname, () => {
console.log(Server running at http://${hostname}:${port}/);
});