Yacht To Ibiza-V3 / Crypto: YTI

Skull & Bones dijo:

TOKENOMICS

MAX SUPPLY
1,000,000,000,000 YTI

FEES
10% FEES DISTRIBUTED AMONG HOLDERS

AUTO LIQUIDITY POOL
LIQUIDITY POOL ALSO RECEIVES ITS SHARE AND MAKES IT STABILIZE THE PRICE.

BURN 15% & DEFLATIONARY
WHEN WE SEND 15% TO DEAD ADDRESS WE MAKE 15% OF THE FEES GO TO DEAD AS WELL, MAKING IT DEFLATIONARY


your fund are SAFU!!!

Hacer clic para expandir...

Kootetsu dijo:

Pero que guano es esto, no me deja poner el medio leru de pena y me dice que 0.001 bnb es más del 10% del supply total

Hacer clic para expandir...

Kootetsu dijo:

Ya, le puse slippage a 12 y me dejó meterle 0.73 lerus en bnb, me costó más el puro gas de comisión, no me dejaba meter ni 1 leru porque el impacto de precio sería demasiado para la moneda.

Ahora soy ultraballena de esta guano, como no me haga millonario las siguentes horas mando 4 senegaleses a tu casa.

Hacer clic para expandir...

Kootetsu dijo:

A ver.. como le entremos 4 mongos más ya tenemos el 100% del supply de tu moneda... ¿y entonces qué?

¿estás seguro que la has creado bien?

Hacer clic para expandir...

Kootetsu dijo:

Me acaba de dar un ictus al ver que la pagina de pancake a la que redirecciona tu web no tenía la dirección correcta y no había candadito... pero me ha entrado automático sino ni de coña conecto metamask a eso.

Me tiene mosca... arreglalo porque la gente si ve la conexión no segura va a pillar paranoia.

Entiendo que el token lo has creado tu... lo que no entiendo es... yo con menos de 1 euro ya soy ultraballena y me ha costado más el gas que la inversión... ¿como esperas hacer crecer esta cosa sin inyectarle ni unos tristes cientos de miles de lerus?

Hacer clic para expandir...

Kootetsu dijo:

Entiendo que el token lo has creado tu... lo que no entiendo es... yo con menos de 1 euro ya soy ultraballena y me ha costado más el gas que la inversión... ¿como esperas hacer crecer esta cosa sin inyectarle ni unos tristes cientos de miles de lerus?

Hacer clic para expandir...

Kootetsu dijo:

Porque pancake no me dejaba meter 1 leru entero... mi idea era meterle 2 o 3, ojo, que puedo repetir solo para tocar los agallas y comprarte todo el stock...

A lo que voy es, a ¿qué impide que tu token se quede sin recorrido en 1 día, en que unos cuantos sucnors hagan agotado el supply y no vendan?

Hacer clic para expandir...

Kootetsu dijo:

Quizás no del todo, pero empezando tan bajo, con que nos metamos 4 o 5 trolls a comprar en 10 minutos podemos controlar un % brutal

Hacer clic para expandir...

pragma solidity >=0.6.0 <0.8.0;

/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}

/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}

/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See:

Tienes que estar registrado para ver este contenido

if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}

/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}

/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}

/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}

/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}

/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}

/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}

/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}

/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}

/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryDiv}.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}

/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}

Hacer clic para expandir...