diff --git a/XChainBridge_8cpp_source.html b/XChainBridge_8cpp_source.html index e45b1d175b..16d15ed602 100644 --- a/XChainBridge_8cpp_source.html +++ b/XChainBridge_8cpp_source.html @@ -1425,847 +1425,853 @@ $(function() {
1452 {
1453  auto const account = ctx.tx[sfAccount];
1454  auto const bridgeSpec = ctx.tx[sfXChainBridge];
-
1455 
-
1456  STXChainBridge::ChainType const chainType =
-
1457  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
-
1458 
-
1459  if (ctx.view.read(keylet::bridge(bridgeSpec, chainType)))
-
1460  {
-
1461  return tecDUPLICATE;
-
1462  }
-
1463 
-
1464  if (!isXRP(bridgeSpec.issue(chainType)))
-
1465  {
-
1466  auto const sleIssuer =
-
1467  ctx.view.read(keylet::account(bridgeSpec.issue(chainType).account));
-
1468 
-
1469  if (!sleIssuer)
-
1470  return tecNO_ISSUER;
-
1471 
-
1472  // Allowing clawing back funds would break the bridge's invariant that
-
1473  // wrapped funds are always backed by locked funds
-
1474  if (sleIssuer->getFlags() & lsfAllowTrustLineClawback)
-
1475  return tecNO_PERMISSION;
-
1476  }
+
1455  STXChainBridge::ChainType const chainType =
+
1456  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
+
1457 
+
1458  {
+
1459  auto hasBridge = [&](STXChainBridge::ChainType ct) -> bool {
+
1460  return ctx.view.exists(keylet::bridge(bridgeSpec, ct));
+
1461  };
+
1462 
+
1463  if (hasBridge(STXChainBridge::ChainType::issuing) ||
+
1464  hasBridge(STXChainBridge::ChainType::locking))
+
1465  {
+
1466  return tecDUPLICATE;
+
1467  }
+
1468  }
+
1469 
+
1470  if (!isXRP(bridgeSpec.issue(chainType)))
+
1471  {
+
1472  auto const sleIssuer =
+
1473  ctx.view.read(keylet::account(bridgeSpec.issue(chainType).account));
+
1474 
+
1475  if (!sleIssuer)
+
1476  return tecNO_ISSUER;
1477 
-
1478  {
-
1479  // Check reserve
-
1480  auto const sleAcc = ctx.view.read(keylet::account(account));
-
1481  if (!sleAcc)
-
1482  return terNO_ACCOUNT;
+
1478  // Allowing clawing back funds would break the bridge's invariant that
+
1479  // wrapped funds are always backed by locked funds
+
1480  if (sleIssuer->getFlags() & lsfAllowTrustLineClawback)
+
1481  return tecNO_PERMISSION;
+
1482  }
1483 
-
1484  auto const balance = (*sleAcc)[sfBalance];
-
1485  auto const reserve =
-
1486  ctx.view.fees().accountReserve((*sleAcc)[sfOwnerCount] + 1);
-
1487 
-
1488  if (balance < reserve)
-
1489  return tecINSUFFICIENT_RESERVE;
-
1490  }
-
1491 
-
1492  return tesSUCCESS;
-
1493 }
-
1494 
-
1495 TER
-
1496 XChainCreateBridge::doApply()
-
1497 {
-
1498  auto const account = ctx_.tx[sfAccount];
-
1499  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
-
1500  auto const reward = ctx_.tx[sfSignatureReward];
-
1501  auto const minAccountCreate = ctx_.tx[~sfMinAccountCreateAmount];
-
1502 
-
1503  auto const sleAcct = ctx_.view().peek(keylet::account(account));
-
1504  if (!sleAcct)
-
1505  return tecINTERNAL;
-
1506 
-
1507  STXChainBridge::ChainType const chainType =
-
1508  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
-
1509 
-
1510  Keylet const bridgeKeylet = keylet::bridge(bridgeSpec, chainType);
-
1511  auto const sleBridge = std::make_shared<SLE>(bridgeKeylet);
+
1484  {
+
1485  // Check reserve
+
1486  auto const sleAcc = ctx.view.read(keylet::account(account));
+
1487  if (!sleAcc)
+
1488  return terNO_ACCOUNT;
+
1489 
+
1490  auto const balance = (*sleAcc)[sfBalance];
+
1491  auto const reserve =
+
1492  ctx.view.fees().accountReserve((*sleAcc)[sfOwnerCount] + 1);
+
1493 
+
1494  if (balance < reserve)
+
1495  return tecINSUFFICIENT_RESERVE;
+
1496  }
+
1497 
+
1498  return tesSUCCESS;
+
1499 }
+
1500 
+
1501 TER
+
1502 XChainCreateBridge::doApply()
+
1503 {
+
1504  auto const account = ctx_.tx[sfAccount];
+
1505  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
+
1506  auto const reward = ctx_.tx[sfSignatureReward];
+
1507  auto const minAccountCreate = ctx_.tx[~sfMinAccountCreateAmount];
+
1508 
+
1509  auto const sleAcct = ctx_.view().peek(keylet::account(account));
+
1510  if (!sleAcct)
+
1511  return tecINTERNAL;
1512 
-
1513  (*sleBridge)[sfAccount] = account;
-
1514  (*sleBridge)[sfSignatureReward] = reward;
-
1515  if (minAccountCreate)
-
1516  (*sleBridge)[sfMinAccountCreateAmount] = *minAccountCreate;
-
1517  (*sleBridge)[sfXChainBridge] = bridgeSpec;
-
1518  (*sleBridge)[sfXChainClaimID] = 0;
-
1519  (*sleBridge)[sfXChainAccountCreateCount] = 0;
-
1520  (*sleBridge)[sfXChainAccountClaimCount] = 0;
-
1521 
-
1522  // Add to owner directory
-
1523  {
-
1524  auto const page = ctx_.view().dirInsert(
-
1525  keylet::ownerDir(account), bridgeKeylet, describeOwnerDir(account));
-
1526  if (!page)
-
1527  return tecDIR_FULL;
-
1528  (*sleBridge)[sfOwnerNode] = *page;
-
1529  }
-
1530 
-
1531  adjustOwnerCount(ctx_.view(), sleAcct, 1, ctx_.journal);
-
1532 
-
1533  ctx_.view().insert(sleBridge);
-
1534  ctx_.view().update(sleAcct);
-
1535 
-
1536  return tesSUCCESS;
-
1537 }
+
1513  STXChainBridge::ChainType const chainType =
+
1514  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
+
1515 
+
1516  Keylet const bridgeKeylet = keylet::bridge(bridgeSpec, chainType);
+
1517  auto const sleBridge = std::make_shared<SLE>(bridgeKeylet);
+
1518 
+
1519  (*sleBridge)[sfAccount] = account;
+
1520  (*sleBridge)[sfSignatureReward] = reward;
+
1521  if (minAccountCreate)
+
1522  (*sleBridge)[sfMinAccountCreateAmount] = *minAccountCreate;
+
1523  (*sleBridge)[sfXChainBridge] = bridgeSpec;
+
1524  (*sleBridge)[sfXChainClaimID] = 0;
+
1525  (*sleBridge)[sfXChainAccountCreateCount] = 0;
+
1526  (*sleBridge)[sfXChainAccountClaimCount] = 0;
+
1527 
+
1528  // Add to owner directory
+
1529  {
+
1530  auto const page = ctx_.view().dirInsert(
+
1531  keylet::ownerDir(account), bridgeKeylet, describeOwnerDir(account));
+
1532  if (!page)
+
1533  return tecDIR_FULL;
+
1534  (*sleBridge)[sfOwnerNode] = *page;
+
1535  }
+
1536 
+
1537  adjustOwnerCount(ctx_.view(), sleAcct, 1, ctx_.journal);
1538 
-
1539 //------------------------------------------------------------------------------
-
1540 
-
1541 NotTEC
-
1542 BridgeModify::preflight(PreflightContext const& ctx)
-
1543 {
-
1544  if (!ctx.rules.enabled(featureXChainBridge))
-
1545  return temDISABLED;
+
1539  ctx_.view().insert(sleBridge);
+
1540  ctx_.view().update(sleAcct);
+
1541 
+
1542  return tesSUCCESS;
+
1543 }
+
1544 
+
1545 //------------------------------------------------------------------------------
1546 
-
1547  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-
1548  return ret;
-
1549 
-
1550  if (ctx.tx.getFlags() & tfBridgeModifyMask)
-
1551  return temINVALID_FLAG;
+
1547 NotTEC
+
1548 BridgeModify::preflight(PreflightContext const& ctx)
+
1549 {
+
1550  if (!ctx.rules.enabled(featureXChainBridge))
+
1551  return temDISABLED;
1552 
-
1553  auto const account = ctx.tx[sfAccount];
-
1554  auto const reward = ctx.tx[~sfSignatureReward];
-
1555  auto const minAccountCreate = ctx.tx[~sfMinAccountCreateAmount];
-
1556  auto const bridgeSpec = ctx.tx[sfXChainBridge];
-
1557  bool const clearAccountCreate =
-
1558  ctx.tx.getFlags() & tfClearAccountCreateAmount;
-
1559 
-
1560  if (!reward && !minAccountCreate && !clearAccountCreate)
-
1561  {
-
1562  // Must change something
-
1563  return temMALFORMED;
-
1564  }
+
1553  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+
1554  return ret;
+
1555 
+
1556  if (ctx.tx.getFlags() & tfBridgeModifyMask)
+
1557  return temINVALID_FLAG;
+
1558 
+
1559  auto const account = ctx.tx[sfAccount];
+
1560  auto const reward = ctx.tx[~sfSignatureReward];
+
1561  auto const minAccountCreate = ctx.tx[~sfMinAccountCreateAmount];
+
1562  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
1563  bool const clearAccountCreate =
+
1564  ctx.tx.getFlags() & tfClearAccountCreateAmount;
1565 
-
1566  if (minAccountCreate && clearAccountCreate)
+
1566  if (!reward && !minAccountCreate && !clearAccountCreate)
1567  {
-
1568  // Can't both clear and set account create in the same txn
+
1568  // Must change something
1569  return temMALFORMED;
1570  }
1571 
-
1572  if (bridgeSpec.lockingChainDoor() != account &&
-
1573  bridgeSpec.issuingChainDoor() != account)
-
1574  {
-
1575  return temXCHAIN_BRIDGE_NONDOOR_OWNER;
+
1572  if (minAccountCreate && clearAccountCreate)
+
1573  {
+
1574  // Can't both clear and set account create in the same txn
+
1575  return temMALFORMED;
1576  }
1577 
-
1578  if (reward && (!isXRP(*reward) || reward->signum() < 0))
-
1579  {
-
1580  return temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT;
-
1581  }
-
1582 
-
1583  if (minAccountCreate &&
-
1584  ((!isXRP(*minAccountCreate) || minAccountCreate->signum() <= 0) ||
-
1585  !isXRP(bridgeSpec.lockingChainIssue()) ||
-
1586  !isXRP(bridgeSpec.issuingChainIssue())))
-
1587  {
-
1588  return temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT;
-
1589  }
-
1590 
-
1591  return preflight2(ctx);
-
1592 }
-
1593 
-
1594 TER
-
1595 BridgeModify::preclaim(PreclaimContext const& ctx)
-
1596 {
-
1597  auto const account = ctx.tx[sfAccount];
-
1598  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
1578  if (bridgeSpec.lockingChainDoor() != account &&
+
1579  bridgeSpec.issuingChainDoor() != account)
+
1580  {
+
1581  return temXCHAIN_BRIDGE_NONDOOR_OWNER;
+
1582  }
+
1583 
+
1584  if (reward && (!isXRP(*reward) || reward->signum() < 0))
+
1585  {
+
1586  return temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT;
+
1587  }
+
1588 
+
1589  if (minAccountCreate &&
+
1590  ((!isXRP(*minAccountCreate) || minAccountCreate->signum() <= 0) ||
+
1591  !isXRP(bridgeSpec.lockingChainIssue()) ||
+
1592  !isXRP(bridgeSpec.issuingChainIssue())))
+
1593  {
+
1594  return temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT;
+
1595  }
+
1596 
+
1597  return preflight2(ctx);
+
1598 }
1599 
-
1600  STXChainBridge::ChainType const chainType =
-
1601  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
-
1602 
-
1603  if (!ctx.view.read(keylet::bridge(bridgeSpec, chainType)))
-
1604  {
-
1605  return tecNO_ENTRY;
-
1606  }
-
1607 
-
1608  return tesSUCCESS;
-
1609 }
-
1610 
-
1611 TER
-
1612 BridgeModify::doApply()
-
1613 {
-
1614  auto const account = ctx_.tx[sfAccount];
-
1615  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
-
1616  auto const reward = ctx_.tx[~sfSignatureReward];
-
1617  auto const minAccountCreate = ctx_.tx[~sfMinAccountCreateAmount];
-
1618  bool const clearAccountCreate =
-
1619  ctx_.tx.getFlags() & tfClearAccountCreateAmount;
-
1620 
-
1621  auto const sleAcct = ctx_.view().peek(keylet::account(account));
-
1622  if (!sleAcct)
-
1623  return tecINTERNAL;
-
1624 
-
1625  STXChainBridge::ChainType const chainType =
-
1626  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
-
1627 
-
1628  auto const sleBridge =
-
1629  ctx_.view().peek(keylet::bridge(bridgeSpec, chainType));
-
1630  if (!sleBridge)
-
1631  return tecINTERNAL;
-
1632 
-
1633  if (reward)
-
1634  (*sleBridge)[sfSignatureReward] = *reward;
-
1635  if (minAccountCreate)
-
1636  {
-
1637  (*sleBridge)[sfMinAccountCreateAmount] = *minAccountCreate;
-
1638  }
-
1639  if (clearAccountCreate &&
-
1640  sleBridge->isFieldPresent(sfMinAccountCreateAmount))
-
1641  {
-
1642  sleBridge->makeFieldAbsent(sfMinAccountCreateAmount);
-
1643  }
-
1644  ctx_.view().update(sleBridge);
-
1645 
-
1646  return tesSUCCESS;
-
1647 }
-
1648 
-
1649 //------------------------------------------------------------------------------
-
1650 
-
1651 NotTEC
-
1652 XChainClaim::preflight(PreflightContext const& ctx)
-
1653 {
-
1654  if (!ctx.rules.enabled(featureXChainBridge))
-
1655  return temDISABLED;
+
1600 TER
+
1601 BridgeModify::preclaim(PreclaimContext const& ctx)
+
1602 {
+
1603  auto const account = ctx.tx[sfAccount];
+
1604  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
1605 
+
1606  STXChainBridge::ChainType const chainType =
+
1607  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
+
1608 
+
1609  if (!ctx.view.read(keylet::bridge(bridgeSpec, chainType)))
+
1610  {
+
1611  return tecNO_ENTRY;
+
1612  }
+
1613 
+
1614  return tesSUCCESS;
+
1615 }
+
1616 
+
1617 TER
+
1618 BridgeModify::doApply()
+
1619 {
+
1620  auto const account = ctx_.tx[sfAccount];
+
1621  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
+
1622  auto const reward = ctx_.tx[~sfSignatureReward];
+
1623  auto const minAccountCreate = ctx_.tx[~sfMinAccountCreateAmount];
+
1624  bool const clearAccountCreate =
+
1625  ctx_.tx.getFlags() & tfClearAccountCreateAmount;
+
1626 
+
1627  auto const sleAcct = ctx_.view().peek(keylet::account(account));
+
1628  if (!sleAcct)
+
1629  return tecINTERNAL;
+
1630 
+
1631  STXChainBridge::ChainType const chainType =
+
1632  STXChainBridge::srcChain(account == bridgeSpec.lockingChainDoor());
+
1633 
+
1634  auto const sleBridge =
+
1635  ctx_.view().peek(keylet::bridge(bridgeSpec, chainType));
+
1636  if (!sleBridge)
+
1637  return tecINTERNAL;
+
1638 
+
1639  if (reward)
+
1640  (*sleBridge)[sfSignatureReward] = *reward;
+
1641  if (minAccountCreate)
+
1642  {
+
1643  (*sleBridge)[sfMinAccountCreateAmount] = *minAccountCreate;
+
1644  }
+
1645  if (clearAccountCreate &&
+
1646  sleBridge->isFieldPresent(sfMinAccountCreateAmount))
+
1647  {
+
1648  sleBridge->makeFieldAbsent(sfMinAccountCreateAmount);
+
1649  }
+
1650  ctx_.view().update(sleBridge);
+
1651 
+
1652  return tesSUCCESS;
+
1653 }
+
1654 
+
1655 //------------------------------------------------------------------------------
1656 
-
1657  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-
1658  return ret;
-
1659 
-
1660  if (ctx.tx.getFlags() & tfUniversalMask)
-
1661  return temINVALID_FLAG;
+
1657 NotTEC
+
1658 XChainClaim::preflight(PreflightContext const& ctx)
+
1659 {
+
1660  if (!ctx.rules.enabled(featureXChainBridge))
+
1661  return temDISABLED;
1662 
-
1663  STXChainBridge const bridgeSpec = ctx.tx[sfXChainBridge];
-
1664  auto const amount = ctx.tx[sfAmount];
+
1663  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+
1664  return ret;
1665 
-
1666  if (amount.signum() <= 0 ||
-
1667  (amount.issue() != bridgeSpec.lockingChainIssue() &&
-
1668  amount.issue() != bridgeSpec.issuingChainIssue()))
-
1669  {
-
1670  return temBAD_AMOUNT;
-
1671  }
-
1672 
-
1673  return preflight2(ctx);
-
1674 }
-
1675 
-
1676 TER
-
1677 XChainClaim::preclaim(PreclaimContext const& ctx)
-
1678 {
-
1679  AccountID const account = ctx.tx[sfAccount];
-
1680  STXChainBridge const bridgeSpec = ctx.tx[sfXChainBridge];
-
1681  STAmount const& thisChainAmount = ctx.tx[sfAmount];
-
1682  auto const claimID = ctx.tx[sfXChainClaimID];
-
1683 
-
1684  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
-
1685  if (!sleBridge)
-
1686  {
-
1687  return tecNO_ENTRY;
-
1688  }
+
1666  if (ctx.tx.getFlags() & tfUniversalMask)
+
1667  return temINVALID_FLAG;
+
1668 
+
1669  STXChainBridge const bridgeSpec = ctx.tx[sfXChainBridge];
+
1670  auto const amount = ctx.tx[sfAmount];
+
1671 
+
1672  if (amount.signum() <= 0 ||
+
1673  (amount.issue() != bridgeSpec.lockingChainIssue() &&
+
1674  amount.issue() != bridgeSpec.issuingChainIssue()))
+
1675  {
+
1676  return temBAD_AMOUNT;
+
1677  }
+
1678 
+
1679  return preflight2(ctx);
+
1680 }
+
1681 
+
1682 TER
+
1683 XChainClaim::preclaim(PreclaimContext const& ctx)
+
1684 {
+
1685  AccountID const account = ctx.tx[sfAccount];
+
1686  STXChainBridge const bridgeSpec = ctx.tx[sfXChainBridge];
+
1687  STAmount const& thisChainAmount = ctx.tx[sfAmount];
+
1688  auto const claimID = ctx.tx[sfXChainClaimID];
1689 
-
1690  if (!ctx.view.read(keylet::account(ctx.tx[sfDestination])))
-
1691  {
-
1692  return tecNO_DST;
-
1693  }
-
1694 
-
1695  auto const thisDoor = (*sleBridge)[sfAccount];
-
1696  bool isLockingChain = false;
+
1690  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
+
1691  if (!sleBridge)
+
1692  {
+
1693  return tecNO_ENTRY;
+
1694  }
+
1695 
+
1696  if (!ctx.view.read(keylet::account(ctx.tx[sfDestination])))
1697  {
-
1698  if (thisDoor == bridgeSpec.lockingChainDoor())
-
1699  isLockingChain = true;
-
1700  else if (thisDoor == bridgeSpec.issuingChainDoor())
-
1701  isLockingChain = false;
-
1702  else
-
1703  return tecINTERNAL;
-
1704  }
-
1705 
-
1706  {
-
1707  // Check that the amount specified matches the expected issue
-
1708 
-
1709  if (isLockingChain)
-
1710  {
-
1711  if (bridgeSpec.lockingChainIssue() != thisChainAmount.issue())
-
1712  return tecXCHAIN_BAD_TRANSFER_ISSUE;
-
1713  }
-
1714  else
-
1715  {
-
1716  if (bridgeSpec.issuingChainIssue() != thisChainAmount.issue())
-
1717  return tecXCHAIN_BAD_TRANSFER_ISSUE;
-
1718  }
-
1719  }
-
1720 
-
1721  if (isXRP(bridgeSpec.lockingChainIssue()) !=
-
1722  isXRP(bridgeSpec.issuingChainIssue()))
-
1723  {
-
1724  // Should have been caught when creating the bridge
-
1725  // Detect here so `otherChainAmount` doesn't switch from IOU -> XRP
-
1726  // and the numeric issues that need to be addressed with that.
-
1727  return tecINTERNAL;
-
1728  }
-
1729 
-
1730  auto const otherChainAmount = [&]() -> STAmount {
-
1731  STAmount r(thisChainAmount);
-
1732  if (isLockingChain)
-
1733  r.setIssue(bridgeSpec.issuingChainIssue());
-
1734  else
-
1735  r.setIssue(bridgeSpec.lockingChainIssue());
-
1736  return r;
-
1737  }();
-
1738 
-
1739  auto const sleClaimID =
-
1740  ctx.view.read(keylet::xChainClaimID(bridgeSpec, claimID));
-
1741  {
-
1742  // Check that the sequence number is owned by the sender of this
-
1743  // transaction
-
1744  if (!sleClaimID)
-
1745  {
-
1746  return tecXCHAIN_NO_CLAIM_ID;
-
1747  }
-
1748 
-
1749  if ((*sleClaimID)[sfAccount] != account)
-
1750  {
-
1751  // Sequence number isn't owned by the sender of this transaction
-
1752  return tecXCHAIN_BAD_CLAIM_ID;
+
1698  return tecNO_DST;
+
1699  }
+
1700 
+
1701  auto const thisDoor = (*sleBridge)[sfAccount];
+
1702  bool isLockingChain = false;
+
1703  {
+
1704  if (thisDoor == bridgeSpec.lockingChainDoor())
+
1705  isLockingChain = true;
+
1706  else if (thisDoor == bridgeSpec.issuingChainDoor())
+
1707  isLockingChain = false;
+
1708  else
+
1709  return tecINTERNAL;
+
1710  }
+
1711 
+
1712  {
+
1713  // Check that the amount specified matches the expected issue
+
1714 
+
1715  if (isLockingChain)
+
1716  {
+
1717  if (bridgeSpec.lockingChainIssue() != thisChainAmount.issue())
+
1718  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
1719  }
+
1720  else
+
1721  {
+
1722  if (bridgeSpec.issuingChainIssue() != thisChainAmount.issue())
+
1723  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
1724  }
+
1725  }
+
1726 
+
1727  if (isXRP(bridgeSpec.lockingChainIssue()) !=
+
1728  isXRP(bridgeSpec.issuingChainIssue()))
+
1729  {
+
1730  // Should have been caught when creating the bridge
+
1731  // Detect here so `otherChainAmount` doesn't switch from IOU -> XRP
+
1732  // and the numeric issues that need to be addressed with that.
+
1733  return tecINTERNAL;
+
1734  }
+
1735 
+
1736  auto const otherChainAmount = [&]() -> STAmount {
+
1737  STAmount r(thisChainAmount);
+
1738  if (isLockingChain)
+
1739  r.setIssue(bridgeSpec.issuingChainIssue());
+
1740  else
+
1741  r.setIssue(bridgeSpec.lockingChainIssue());
+
1742  return r;
+
1743  }();
+
1744 
+
1745  auto const sleClaimID =
+
1746  ctx.view.read(keylet::xChainClaimID(bridgeSpec, claimID));
+
1747  {
+
1748  // Check that the sequence number is owned by the sender of this
+
1749  // transaction
+
1750  if (!sleClaimID)
+
1751  {
+
1752  return tecXCHAIN_NO_CLAIM_ID;
1753  }
-
1754  }
-
1755 
-
1756  // quorum is checked in `doApply`
-
1757  return tesSUCCESS;
-
1758 }
-
1759 
-
1760 TER
-
1761 XChainClaim::doApply()
-
1762 {
-
1763  PaymentSandbox psb(&ctx_.view());
-
1764 
-
1765  AccountID const account = ctx_.tx[sfAccount];
-
1766  auto const dst = ctx_.tx[sfDestination];
-
1767  STXChainBridge const bridgeSpec = ctx_.tx[sfXChainBridge];
-
1768  STAmount const& thisChainAmount = ctx_.tx[sfAmount];
-
1769  auto const claimID = ctx_.tx[sfXChainClaimID];
-
1770  auto const claimIDKeylet = keylet::xChainClaimID(bridgeSpec, claimID);
-
1771 
-
1772  struct ScopeResult
-
1773  {
-
1774  std::vector<AccountID> rewardAccounts;
-
1775  AccountID rewardPoolSrc;
-
1776  STAmount sendingAmount;
-
1777  STXChainBridge::ChainType srcChain;
-
1778  STAmount signatureReward;
-
1779  };
-
1780 
-
1781  auto const scopeResult = [&]() -> Expected<ScopeResult, TER> {
-
1782  // This lambda is ugly - admittedly. The purpose of this lambda is to
-
1783  // limit the scope of sles so they don't overlap with
-
1784  // `finalizeClaimHelper`. Since `finalizeClaimHelper` can create child
-
1785  // views, it's important that the sle's lifetime doesn't overlap.
+
1754 
+
1755  if ((*sleClaimID)[sfAccount] != account)
+
1756  {
+
1757  // Sequence number isn't owned by the sender of this transaction
+
1758  return tecXCHAIN_BAD_CLAIM_ID;
+
1759  }
+
1760  }
+
1761 
+
1762  // quorum is checked in `doApply`
+
1763  return tesSUCCESS;
+
1764 }
+
1765 
+
1766 TER
+
1767 XChainClaim::doApply()
+
1768 {
+
1769  PaymentSandbox psb(&ctx_.view());
+
1770 
+
1771  AccountID const account = ctx_.tx[sfAccount];
+
1772  auto const dst = ctx_.tx[sfDestination];
+
1773  STXChainBridge const bridgeSpec = ctx_.tx[sfXChainBridge];
+
1774  STAmount const& thisChainAmount = ctx_.tx[sfAmount];
+
1775  auto const claimID = ctx_.tx[sfXChainClaimID];
+
1776  auto const claimIDKeylet = keylet::xChainClaimID(bridgeSpec, claimID);
+
1777 
+
1778  struct ScopeResult
+
1779  {
+
1780  std::vector<AccountID> rewardAccounts;
+
1781  AccountID rewardPoolSrc;
+
1782  STAmount sendingAmount;
+
1783  STXChainBridge::ChainType srcChain;
+
1784  STAmount signatureReward;
+
1785  };
1786 
-
1787  auto const sleAcct = psb.peek(keylet::account(account));
-
1788  auto const sleBridge = peekBridge(psb, bridgeSpec);
-
1789  auto const sleClaimID = psb.peek(claimIDKeylet);
-
1790 
-
1791  if (!(sleBridge && sleClaimID && sleAcct))
-
1792  return Unexpected(tecINTERNAL);
-
1793 
-
1794  AccountID const thisDoor = (*sleBridge)[sfAccount];
-
1795 
-
1796  STXChainBridge::ChainType dstChain = STXChainBridge::ChainType::locking;
-
1797  {
-
1798  if (thisDoor == bridgeSpec.lockingChainDoor())
-
1799  dstChain = STXChainBridge::ChainType::locking;
-
1800  else if (thisDoor == bridgeSpec.issuingChainDoor())
-
1801  dstChain = STXChainBridge::ChainType::issuing;
-
1802  else
-
1803  return Unexpected(tecINTERNAL);
-
1804  }
-
1805  STXChainBridge::ChainType const srcChain =
-
1806  STXChainBridge::otherChain(dstChain);
-
1807 
-
1808  auto const sendingAmount = [&]() -> STAmount {
-
1809  STAmount r(thisChainAmount);
-
1810  r.setIssue(bridgeSpec.issue(srcChain));
-
1811  return r;
-
1812  }();
+
1787  auto const scopeResult = [&]() -> Expected<ScopeResult, TER> {
+
1788  // This lambda is ugly - admittedly. The purpose of this lambda is to
+
1789  // limit the scope of sles so they don't overlap with
+
1790  // `finalizeClaimHelper`. Since `finalizeClaimHelper` can create child
+
1791  // views, it's important that the sle's lifetime doesn't overlap.
+
1792 
+
1793  auto const sleAcct = psb.peek(keylet::account(account));
+
1794  auto const sleBridge = peekBridge(psb, bridgeSpec);
+
1795  auto const sleClaimID = psb.peek(claimIDKeylet);
+
1796 
+
1797  if (!(sleBridge && sleClaimID && sleAcct))
+
1798  return Unexpected(tecINTERNAL);
+
1799 
+
1800  AccountID const thisDoor = (*sleBridge)[sfAccount];
+
1801 
+
1802  STXChainBridge::ChainType dstChain = STXChainBridge::ChainType::locking;
+
1803  {
+
1804  if (thisDoor == bridgeSpec.lockingChainDoor())
+
1805  dstChain = STXChainBridge::ChainType::locking;
+
1806  else if (thisDoor == bridgeSpec.issuingChainDoor())
+
1807  dstChain = STXChainBridge::ChainType::issuing;
+
1808  else
+
1809  return Unexpected(tecINTERNAL);
+
1810  }
+
1811  STXChainBridge::ChainType const srcChain =
+
1812  STXChainBridge::otherChain(dstChain);
1813 
-
1814  auto const [signersList, quorum, slTer] =
-
1815  getSignersListAndQuorum(ctx_.view(), *sleBridge, ctx_.journal);
-
1816 
-
1817  if (!isTesSuccess(slTer))
-
1818  return Unexpected(slTer);
+
1814  auto const sendingAmount = [&]() -> STAmount {
+
1815  STAmount r(thisChainAmount);
+
1816  r.setIssue(bridgeSpec.issue(srcChain));
+
1817  return r;
+
1818  }();
1819 
-
1820  XChainClaimAttestations curAtts{
-
1821  sleClaimID->getFieldArray(sfXChainClaimAttestations)};
+
1820  auto const [signersList, quorum, slTer] =
+
1821  getSignersListAndQuorum(ctx_.view(), *sleBridge, ctx_.journal);
1822 
-
1823  auto const claimR = onClaim(
-
1824  curAtts,
-
1825  psb,
-
1826  sendingAmount,
-
1827  /*wasLockingChainSend*/ srcChain ==
-
1828  STXChainBridge::ChainType::locking,
-
1829  quorum,
-
1830  signersList,
-
1831  ctx_.journal);
-
1832  if (!claimR.has_value())
-
1833  return Unexpected(claimR.error());
-
1834 
-
1835  return ScopeResult{
-
1836  claimR.value(),
-
1837  (*sleClaimID)[sfAccount],
-
1838  sendingAmount,
-
1839  srcChain,
-
1840  (*sleClaimID)[sfSignatureReward],
-
1841  };
-
1842  }();
-
1843 
-
1844  if (!scopeResult.has_value())
-
1845  return scopeResult.error();
-
1846 
-
1847  auto const& [rewardAccounts, rewardPoolSrc, sendingAmount, srcChain, signatureReward] =
-
1848  scopeResult.value();
-
1849  std::optional<std::uint32_t> const dstTag = ctx_.tx[~sfDestinationTag];
-
1850 
-
1851  auto const r = finalizeClaimHelper(
-
1852  psb,
-
1853  bridgeSpec,
-
1854  dst,
-
1855  dstTag,
-
1856  /*claimOwner*/ account,
-
1857  sendingAmount,
-
1858  rewardPoolSrc,
-
1859  signatureReward,
-
1860  rewardAccounts,
-
1861  srcChain,
-
1862  claimIDKeylet,
-
1863  OnTransferFail::keepClaim,
-
1864  DepositAuthPolicy::dstCanBypass,
-
1865  ctx_.journal);
-
1866  if (!r.isTesSuccess())
-
1867  return r.ter();
-
1868 
-
1869  psb.apply(ctx_.rawView());
-
1870 
-
1871  return tesSUCCESS;
-
1872 }
-
1873 
-
1874 //------------------------------------------------------------------------------
-
1875 
-
1876 TxConsequences
-
1877 XChainCommit::makeTxConsequences(PreflightContext const& ctx)
-
1878 {
-
1879  auto const maxSpend = [&] {
-
1880  auto const amount = ctx.tx[sfAmount];
-
1881  if (amount.native() && amount.signum() > 0)
-
1882  return amount.xrp();
-
1883  return XRPAmount{beast::zero};
-
1884  }();
-
1885 
-
1886  return TxConsequences{ctx.tx, maxSpend};
-
1887 }
-
1888 
-
1889 NotTEC
-
1890 XChainCommit::preflight(PreflightContext const& ctx)
-
1891 {
-
1892  if (!ctx.rules.enabled(featureXChainBridge))
-
1893  return temDISABLED;
+
1823  if (!isTesSuccess(slTer))
+
1824  return Unexpected(slTer);
+
1825 
+
1826  XChainClaimAttestations curAtts{
+
1827  sleClaimID->getFieldArray(sfXChainClaimAttestations)};
+
1828 
+
1829  auto const claimR = onClaim(
+
1830  curAtts,
+
1831  psb,
+
1832  sendingAmount,
+
1833  /*wasLockingChainSend*/ srcChain ==
+
1834  STXChainBridge::ChainType::locking,
+
1835  quorum,
+
1836  signersList,
+
1837  ctx_.journal);
+
1838  if (!claimR.has_value())
+
1839  return Unexpected(claimR.error());
+
1840 
+
1841  return ScopeResult{
+
1842  claimR.value(),
+
1843  (*sleClaimID)[sfAccount],
+
1844  sendingAmount,
+
1845  srcChain,
+
1846  (*sleClaimID)[sfSignatureReward],
+
1847  };
+
1848  }();
+
1849 
+
1850  if (!scopeResult.has_value())
+
1851  return scopeResult.error();
+
1852 
+
1853  auto const& [rewardAccounts, rewardPoolSrc, sendingAmount, srcChain, signatureReward] =
+
1854  scopeResult.value();
+
1855  std::optional<std::uint32_t> const dstTag = ctx_.tx[~sfDestinationTag];
+
1856 
+
1857  auto const r = finalizeClaimHelper(
+
1858  psb,
+
1859  bridgeSpec,
+
1860  dst,
+
1861  dstTag,
+
1862  /*claimOwner*/ account,
+
1863  sendingAmount,
+
1864  rewardPoolSrc,
+
1865  signatureReward,
+
1866  rewardAccounts,
+
1867  srcChain,
+
1868  claimIDKeylet,
+
1869  OnTransferFail::keepClaim,
+
1870  DepositAuthPolicy::dstCanBypass,
+
1871  ctx_.journal);
+
1872  if (!r.isTesSuccess())
+
1873  return r.ter();
+
1874 
+
1875  psb.apply(ctx_.rawView());
+
1876 
+
1877  return tesSUCCESS;
+
1878 }
+
1879 
+
1880 //------------------------------------------------------------------------------
+
1881 
+
1882 TxConsequences
+
1883 XChainCommit::makeTxConsequences(PreflightContext const& ctx)
+
1884 {
+
1885  auto const maxSpend = [&] {
+
1886  auto const amount = ctx.tx[sfAmount];
+
1887  if (amount.native() && amount.signum() > 0)
+
1888  return amount.xrp();
+
1889  return XRPAmount{beast::zero};
+
1890  }();
+
1891 
+
1892  return TxConsequences{ctx.tx, maxSpend};
+
1893 }
1894 
-
1895  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-
1896  return ret;
-
1897 
-
1898  if (ctx.tx.getFlags() & tfUniversalMask)
-
1899  return temINVALID_FLAG;
+
1895 NotTEC
+
1896 XChainCommit::preflight(PreflightContext const& ctx)
+
1897 {
+
1898  if (!ctx.rules.enabled(featureXChainBridge))
+
1899  return temDISABLED;
1900 
-
1901  auto const amount = ctx.tx[sfAmount];
-
1902  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
1901  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+
1902  return ret;
1903 
-
1904  if (amount.signum() <= 0 || !isLegalNet(amount))
-
1905  return temBAD_AMOUNT;
+
1904  if (ctx.tx.getFlags() & tfUniversalMask)
+
1905  return temINVALID_FLAG;
1906 
-
1907  if (amount.issue() != bridgeSpec.lockingChainIssue() &&
-
1908  amount.issue() != bridgeSpec.issuingChainIssue())
-
1909  return temBAD_ISSUER;
-
1910 
-
1911  return preflight2(ctx);
-
1912 }
-
1913 
-
1914 TER
-
1915 XChainCommit::preclaim(PreclaimContext const& ctx)
-
1916 {
-
1917  auto const bridgeSpec = ctx.tx[sfXChainBridge];
-
1918  auto const amount = ctx.tx[sfAmount];
+
1907  auto const amount = ctx.tx[sfAmount];
+
1908  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
1909 
+
1910  if (amount.signum() <= 0 || !isLegalNet(amount))
+
1911  return temBAD_AMOUNT;
+
1912 
+
1913  if (amount.issue() != bridgeSpec.lockingChainIssue() &&
+
1914  amount.issue() != bridgeSpec.issuingChainIssue())
+
1915  return temBAD_ISSUER;
+
1916 
+
1917  return preflight2(ctx);
+
1918 }
1919 
-
1920  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
-
1921  if (!sleBridge)
-
1922  {
-
1923  return tecNO_ENTRY;
-
1924  }
+
1920 TER
+
1921 XChainCommit::preclaim(PreclaimContext const& ctx)
+
1922 {
+
1923  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
1924  auto const amount = ctx.tx[sfAmount];
1925 
-
1926  AccountID const thisDoor = (*sleBridge)[sfAccount];
-
1927  AccountID const account = ctx.tx[sfAccount];
-
1928 
-
1929  if (thisDoor == account)
-
1930  {
-
1931  // Door account can't lock funds onto itself
-
1932  return tecXCHAIN_SELF_COMMIT;
-
1933  }
+
1926  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
+
1927  if (!sleBridge)
+
1928  {
+
1929  return tecNO_ENTRY;
+
1930  }
+
1931 
+
1932  AccountID const thisDoor = (*sleBridge)[sfAccount];
+
1933  AccountID const account = ctx.tx[sfAccount];
1934 
-
1935  bool isLockingChain = false;
+
1935  if (thisDoor == account)
1936  {
-
1937  if (thisDoor == bridgeSpec.lockingChainDoor())
-
1938  isLockingChain = true;
-
1939  else if (thisDoor == bridgeSpec.issuingChainDoor())
-
1940  isLockingChain = false;
-
1941  else
-
1942  return tecINTERNAL;
-
1943  }
-
1944 
-
1945  if (isLockingChain)
-
1946  {
-
1947  if (bridgeSpec.lockingChainIssue() != ctx.tx[sfAmount].issue())
-
1948  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
1937  // Door account can't lock funds onto itself
+
1938  return tecXCHAIN_SELF_COMMIT;
+
1939  }
+
1940 
+
1941  bool isLockingChain = false;
+
1942  {
+
1943  if (thisDoor == bridgeSpec.lockingChainDoor())
+
1944  isLockingChain = true;
+
1945  else if (thisDoor == bridgeSpec.issuingChainDoor())
+
1946  isLockingChain = false;
+
1947  else
+
1948  return tecINTERNAL;
1949  }
-
1950  else
-
1951  {
-
1952  if (bridgeSpec.issuingChainIssue() != ctx.tx[sfAmount].issue())
-
1953  return tecXCHAIN_BAD_TRANSFER_ISSUE;
-
1954  }
-
1955 
-
1956  return tesSUCCESS;
-
1957 }
-
1958 
-
1959 TER
-
1960 XChainCommit::doApply()
-
1961 {
-
1962  PaymentSandbox psb(&ctx_.view());
-
1963 
-
1964  auto const account = ctx_.tx[sfAccount];
-
1965  auto const amount = ctx_.tx[sfAmount];
-
1966  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
-
1967 
-
1968  if (!psb.read(keylet::account(account)))
-
1969  return tecINTERNAL;
-
1970 
-
1971  auto const sleBridge = readBridge(psb, bridgeSpec);
-
1972  if (!sleBridge)
-
1973  return tecINTERNAL;
-
1974 
-
1975  auto const dst = (*sleBridge)[sfAccount];
+
1950 
+
1951  if (isLockingChain)
+
1952  {
+
1953  if (bridgeSpec.lockingChainIssue() != ctx.tx[sfAmount].issue())
+
1954  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
1955  }
+
1956  else
+
1957  {
+
1958  if (bridgeSpec.issuingChainIssue() != ctx.tx[sfAmount].issue())
+
1959  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
1960  }
+
1961 
+
1962  return tesSUCCESS;
+
1963 }
+
1964 
+
1965 TER
+
1966 XChainCommit::doApply()
+
1967 {
+
1968  PaymentSandbox psb(&ctx_.view());
+
1969 
+
1970  auto const account = ctx_.tx[sfAccount];
+
1971  auto const amount = ctx_.tx[sfAmount];
+
1972  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
+
1973 
+
1974  if (!psb.read(keylet::account(account)))
+
1975  return tecINTERNAL;
1976 
-
1977  // Support dipping into reserves to pay the fee
-
1978  TransferHelperSubmittingAccountInfo submittingAccountInfo{
-
1979  account_, mPriorBalance, mSourceBalance};
+
1977  auto const sleBridge = readBridge(psb, bridgeSpec);
+
1978  if (!sleBridge)
+
1979  return tecINTERNAL;
1980 
-
1981  auto const thTer = transferHelper(
-
1982  psb,
-
1983  account,
-
1984  dst,
-
1985  /*dstTag*/ std::nullopt,
-
1986  /*claimOwner*/ std::nullopt,
-
1987  amount,
-
1988  CanCreateDstPolicy::no,
-
1989  DepositAuthPolicy::normal,
-
1990  submittingAccountInfo,
-
1991  ctx_.journal);
-
1992 
-
1993  if (!isTesSuccess(thTer))
-
1994  return thTer;
-
1995 
-
1996  psb.apply(ctx_.rawView());
-
1997 
-
1998  return tesSUCCESS;
-
1999 }
-
2000 
-
2001 //------------------------------------------------------------------------------
-
2002 
-
2003 NotTEC
-
2004 XChainCreateClaimID::preflight(PreflightContext const& ctx)
-
2005 {
-
2006  if (!ctx.rules.enabled(featureXChainBridge))
-
2007  return temDISABLED;
+
1981  auto const dst = (*sleBridge)[sfAccount];
+
1982 
+
1983  // Support dipping into reserves to pay the fee
+
1984  TransferHelperSubmittingAccountInfo submittingAccountInfo{
+
1985  account_, mPriorBalance, mSourceBalance};
+
1986 
+
1987  auto const thTer = transferHelper(
+
1988  psb,
+
1989  account,
+
1990  dst,
+
1991  /*dstTag*/ std::nullopt,
+
1992  /*claimOwner*/ std::nullopt,
+
1993  amount,
+
1994  CanCreateDstPolicy::no,
+
1995  DepositAuthPolicy::normal,
+
1996  submittingAccountInfo,
+
1997  ctx_.journal);
+
1998 
+
1999  if (!isTesSuccess(thTer))
+
2000  return thTer;
+
2001 
+
2002  psb.apply(ctx_.rawView());
+
2003 
+
2004  return tesSUCCESS;
+
2005 }
+
2006 
+
2007 //------------------------------------------------------------------------------
2008 
-
2009  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-
2010  return ret;
-
2011 
-
2012  if (ctx.tx.getFlags() & tfUniversalMask)
-
2013  return temINVALID_FLAG;
+
2009 NotTEC
+
2010 XChainCreateClaimID::preflight(PreflightContext const& ctx)
+
2011 {
+
2012  if (!ctx.rules.enabled(featureXChainBridge))
+
2013  return temDISABLED;
2014 
-
2015  auto const reward = ctx.tx[sfSignatureReward];
-
2016 
-
2017  if (!isXRP(reward) || reward.signum() < 0 || !isLegalNet(reward))
-
2018  return temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT;
-
2019 
-
2020  return preflight2(ctx);
-
2021 }
+
2015  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+
2016  return ret;
+
2017 
+
2018  if (ctx.tx.getFlags() & tfUniversalMask)
+
2019  return temINVALID_FLAG;
+
2020 
+
2021  auto const reward = ctx.tx[sfSignatureReward];
2022 
-
2023 TER
-
2024 XChainCreateClaimID::preclaim(PreclaimContext const& ctx)
-
2025 {
-
2026  auto const account = ctx.tx[sfAccount];
-
2027  auto const bridgeSpec = ctx.tx[sfXChainBridge];
-
2028  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
-
2029 
-
2030  if (!sleBridge)
-
2031  {
-
2032  return tecNO_ENTRY;
-
2033  }
-
2034 
-
2035  // Check that the reward matches
-
2036  auto const reward = ctx.tx[sfSignatureReward];
-
2037 
-
2038  if (reward != (*sleBridge)[sfSignatureReward])
-
2039  {
-
2040  return tecXCHAIN_REWARD_MISMATCH;
-
2041  }
-
2042 
-
2043  {
-
2044  // Check reserve
-
2045  auto const sleAcc = ctx.view.read(keylet::account(account));
-
2046  if (!sleAcc)
-
2047  return terNO_ACCOUNT;
+
2023  if (!isXRP(reward) || reward.signum() < 0 || !isLegalNet(reward))
+
2024  return temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT;
+
2025 
+
2026  return preflight2(ctx);
+
2027 }
+
2028 
+
2029 TER
+
2030 XChainCreateClaimID::preclaim(PreclaimContext const& ctx)
+
2031 {
+
2032  auto const account = ctx.tx[sfAccount];
+
2033  auto const bridgeSpec = ctx.tx[sfXChainBridge];
+
2034  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
+
2035 
+
2036  if (!sleBridge)
+
2037  {
+
2038  return tecNO_ENTRY;
+
2039  }
+
2040 
+
2041  // Check that the reward matches
+
2042  auto const reward = ctx.tx[sfSignatureReward];
+
2043 
+
2044  if (reward != (*sleBridge)[sfSignatureReward])
+
2045  {
+
2046  return tecXCHAIN_REWARD_MISMATCH;
+
2047  }
2048 
-
2049  auto const balance = (*sleAcc)[sfBalance];
-
2050  auto const reserve =
-
2051  ctx.view.fees().accountReserve((*sleAcc)[sfOwnerCount] + 1);
-
2052 
-
2053  if (balance < reserve)
-
2054  return tecINSUFFICIENT_RESERVE;
-
2055  }
-
2056 
-
2057  return tesSUCCESS;
-
2058 }
-
2059 
-
2060 TER
-
2061 XChainCreateClaimID::doApply()
-
2062 {
-
2063  auto const account = ctx_.tx[sfAccount];
-
2064  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
-
2065  auto const reward = ctx_.tx[sfSignatureReward];
-
2066  auto const otherChainSrc = ctx_.tx[sfOtherChainSource];
-
2067 
-
2068  auto const sleAcct = ctx_.view().peek(keylet::account(account));
-
2069  if (!sleAcct)
-
2070  return tecINTERNAL;
-
2071 
-
2072  auto const sleBridge = peekBridge(ctx_.view(), bridgeSpec);
-
2073  if (!sleBridge)
-
2074  return tecINTERNAL;
-
2075 
-
2076  std::uint32_t const claimID = (*sleBridge)[sfXChainClaimID] + 1;
-
2077  if (claimID == 0)
-
2078  return tecINTERNAL; // overflow
-
2079 
-
2080  (*sleBridge)[sfXChainClaimID] = claimID;
+
2049  {
+
2050  // Check reserve
+
2051  auto const sleAcc = ctx.view.read(keylet::account(account));
+
2052  if (!sleAcc)
+
2053  return terNO_ACCOUNT;
+
2054 
+
2055  auto const balance = (*sleAcc)[sfBalance];
+
2056  auto const reserve =
+
2057  ctx.view.fees().accountReserve((*sleAcc)[sfOwnerCount] + 1);
+
2058 
+
2059  if (balance < reserve)
+
2060  return tecINSUFFICIENT_RESERVE;
+
2061  }
+
2062 
+
2063  return tesSUCCESS;
+
2064 }
+
2065 
+
2066 TER
+
2067 XChainCreateClaimID::doApply()
+
2068 {
+
2069  auto const account = ctx_.tx[sfAccount];
+
2070  auto const bridgeSpec = ctx_.tx[sfXChainBridge];
+
2071  auto const reward = ctx_.tx[sfSignatureReward];
+
2072  auto const otherChainSrc = ctx_.tx[sfOtherChainSource];
+
2073 
+
2074  auto const sleAcct = ctx_.view().peek(keylet::account(account));
+
2075  if (!sleAcct)
+
2076  return tecINTERNAL;
+
2077 
+
2078  auto const sleBridge = peekBridge(ctx_.view(), bridgeSpec);
+
2079  if (!sleBridge)
+
2080  return tecINTERNAL;
2081 
-
2082  Keylet const claimIDKeylet = keylet::xChainClaimID(bridgeSpec, claimID);
-
2083  if (ctx_.view().exists(claimIDKeylet))
-
2084  return tecINTERNAL; // already checked out!?!
+
2082  std::uint32_t const claimID = (*sleBridge)[sfXChainClaimID] + 1;
+
2083  if (claimID == 0)
+
2084  return tecINTERNAL; // overflow
2085 
-
2086  auto const sleClaimID = std::make_shared<SLE>(claimIDKeylet);
+
2086  (*sleBridge)[sfXChainClaimID] = claimID;
2087 
-
2088  (*sleClaimID)[sfAccount] = account;
-
2089  (*sleClaimID)[sfXChainBridge] = bridgeSpec;
-
2090  (*sleClaimID)[sfXChainClaimID] = claimID;
-
2091  (*sleClaimID)[sfOtherChainSource] = otherChainSrc;
-
2092  (*sleClaimID)[sfSignatureReward] = reward;
-
2093  sleClaimID->setFieldArray(
-
2094  sfXChainClaimAttestations, STArray{sfXChainClaimAttestations});
-
2095 
-
2096  // Add to owner directory
-
2097  {
-
2098  auto const page = ctx_.view().dirInsert(
-
2099  keylet::ownerDir(account),
-
2100  claimIDKeylet,
-
2101  describeOwnerDir(account));
-
2102  if (!page)
-
2103  return tecDIR_FULL;
-
2104  (*sleClaimID)[sfOwnerNode] = *page;
-
2105  }
-
2106 
-
2107  adjustOwnerCount(ctx_.view(), sleAcct, 1, ctx_.journal);
-
2108 
-
2109  ctx_.view().insert(sleClaimID);
-
2110  ctx_.view().update(sleBridge);
-
2111  ctx_.view().update(sleAcct);
+
2088  Keylet const claimIDKeylet = keylet::xChainClaimID(bridgeSpec, claimID);
+
2089  if (ctx_.view().exists(claimIDKeylet))
+
2090  return tecINTERNAL; // already checked out!?!
+
2091 
+
2092  auto const sleClaimID = std::make_shared<SLE>(claimIDKeylet);
+
2093 
+
2094  (*sleClaimID)[sfAccount] = account;
+
2095  (*sleClaimID)[sfXChainBridge] = bridgeSpec;
+
2096  (*sleClaimID)[sfXChainClaimID] = claimID;
+
2097  (*sleClaimID)[sfOtherChainSource] = otherChainSrc;
+
2098  (*sleClaimID)[sfSignatureReward] = reward;
+
2099  sleClaimID->setFieldArray(
+
2100  sfXChainClaimAttestations, STArray{sfXChainClaimAttestations});
+
2101 
+
2102  // Add to owner directory
+
2103  {
+
2104  auto const page = ctx_.view().dirInsert(
+
2105  keylet::ownerDir(account),
+
2106  claimIDKeylet,
+
2107  describeOwnerDir(account));
+
2108  if (!page)
+
2109  return tecDIR_FULL;
+
2110  (*sleClaimID)[sfOwnerNode] = *page;
+
2111  }
2112 
-
2113  return tesSUCCESS;
-
2114 }
-
2115 
-
2116 //------------------------------------------------------------------------------
-
2117 
-
2118 NotTEC
-
2119 XChainAddClaimAttestation::preflight(PreflightContext const& ctx)
-
2120 {
-
2121  return attestationPreflight<Attestations::AttestationClaim>(ctx);
-
2122 }
+
2113  adjustOwnerCount(ctx_.view(), sleAcct, 1, ctx_.journal);
+
2114 
+
2115  ctx_.view().insert(sleClaimID);
+
2116  ctx_.view().update(sleBridge);
+
2117  ctx_.view().update(sleAcct);
+
2118 
+
2119  return tesSUCCESS;
+
2120 }
+
2121 
+
2122 //------------------------------------------------------------------------------
2123 
-
2124 TER
-
2125 XChainAddClaimAttestation::preclaim(PreclaimContext const& ctx)
+
2124 NotTEC
+
2125 XChainAddClaimAttestation::preflight(PreflightContext const& ctx)
2126 {
-
2127  return attestationPreclaim<Attestations::AttestationClaim>(ctx);
+
2127  return attestationPreflight<Attestations::AttestationClaim>(ctx);
2128 }
2129 
2130 TER
-
2131 XChainAddClaimAttestation::doApply()
+
2131 XChainAddClaimAttestation::preclaim(PreclaimContext const& ctx)
2132 {
-
2133  return attestationDoApply<Attestations::AttestationClaim>(ctx_);
+
2133  return attestationPreclaim<Attestations::AttestationClaim>(ctx);
2134 }
2135 
-
2136 //------------------------------------------------------------------------------
-
2137 
-
2138 NotTEC
-
2139 XChainAddAccountCreateAttestation::preflight(PreflightContext const& ctx)
-
2140 {
-
2141  return attestationPreflight<Attestations::AttestationCreateAccount>(ctx);
-
2142 }
+
2136 TER
+
2137 XChainAddClaimAttestation::doApply()
+
2138 {
+
2139  return attestationDoApply<Attestations::AttestationClaim>(ctx_);
+
2140 }
+
2141 
+
2142 //------------------------------------------------------------------------------
2143 
-
2144 TER
-
2145 XChainAddAccountCreateAttestation::preclaim(PreclaimContext const& ctx)
+
2144 NotTEC
+
2145 XChainAddAccountCreateAttestation::preflight(PreflightContext const& ctx)
2146 {
-
2147  return attestationPreclaim<Attestations::AttestationCreateAccount>(ctx);
+
2147  return attestationPreflight<Attestations::AttestationCreateAccount>(ctx);
2148 }
2149 
2150 TER
-
2151 XChainAddAccountCreateAttestation::doApply()
+
2151 XChainAddAccountCreateAttestation::preclaim(PreclaimContext const& ctx)
2152 {
-
2153  return attestationDoApply<Attestations::AttestationCreateAccount>(ctx_);
+
2153  return attestationPreclaim<Attestations::AttestationCreateAccount>(ctx);
2154 }
2155 
-
2156 //------------------------------------------------------------------------------
-
2157 
-
2158 NotTEC
-
2159 XChainCreateAccountCommit::preflight(PreflightContext const& ctx)
-
2160 {
-
2161  if (!ctx.rules.enabled(featureXChainBridge))
-
2162  return temDISABLED;
+
2156 TER
+
2157 XChainAddAccountCreateAttestation::doApply()
+
2158 {
+
2159  return attestationDoApply<Attestations::AttestationCreateAccount>(ctx_);
+
2160 }
+
2161 
+
2162 //------------------------------------------------------------------------------
2163 
-
2164  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-
2165  return ret;
-
2166 
-
2167  if (ctx.tx.getFlags() & tfUniversalMask)
-
2168  return temINVALID_FLAG;
+
2164 NotTEC
+
2165 XChainCreateAccountCommit::preflight(PreflightContext const& ctx)
+
2166 {
+
2167  if (!ctx.rules.enabled(featureXChainBridge))
+
2168  return temDISABLED;
2169 
-
2170  auto const amount = ctx.tx[sfAmount];
-
2171 
-
2172  if (amount.signum() <= 0 || !amount.native())
-
2173  return temBAD_AMOUNT;
-
2174 
-
2175  auto const reward = ctx.tx[sfSignatureReward];
-
2176  if (reward.signum() < 0 || !reward.native())
-
2177  return temBAD_AMOUNT;
-
2178 
-
2179  if (reward.issue() != amount.issue())
-
2180  return temBAD_AMOUNT;
-
2181 
-
2182  return preflight2(ctx);
-
2183 }
+
2170  if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
+
2171  return ret;
+
2172 
+
2173  if (ctx.tx.getFlags() & tfUniversalMask)
+
2174  return temINVALID_FLAG;
+
2175 
+
2176  auto const amount = ctx.tx[sfAmount];
+
2177 
+
2178  if (amount.signum() <= 0 || !amount.native())
+
2179  return temBAD_AMOUNT;
+
2180 
+
2181  auto const reward = ctx.tx[sfSignatureReward];
+
2182  if (reward.signum() < 0 || !reward.native())
+
2183  return temBAD_AMOUNT;
2184 
-
2185 TER
-
2186 XChainCreateAccountCommit::preclaim(PreclaimContext const& ctx)
-
2187 {
-
2188  STXChainBridge const bridgeSpec = ctx.tx[sfXChainBridge];
-
2189  STAmount const amount = ctx.tx[sfAmount];
-
2190  STAmount const reward = ctx.tx[sfSignatureReward];
-
2191 
-
2192  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
-
2193  if (!sleBridge)
-
2194  {
-
2195  return tecNO_ENTRY;
-
2196  }
+
2185  if (reward.issue() != amount.issue())
+
2186  return temBAD_AMOUNT;
+
2187 
+
2188  return preflight2(ctx);
+
2189 }
+
2190 
+
2191 TER
+
2192 XChainCreateAccountCommit::preclaim(PreclaimContext const& ctx)
+
2193 {
+
2194  STXChainBridge const bridgeSpec = ctx.tx[sfXChainBridge];
+
2195  STAmount const amount = ctx.tx[sfAmount];
+
2196  STAmount const reward = ctx.tx[sfSignatureReward];
2197 
-
2198  if (reward != (*sleBridge)[sfSignatureReward])
-
2199  {
-
2200  return tecXCHAIN_REWARD_MISMATCH;
-
2201  }
-
2202 
-
2203  std::optional<STAmount> const minCreateAmount =
-
2204  (*sleBridge)[~sfMinAccountCreateAmount];
-
2205 
-
2206  if (!minCreateAmount)
-
2207  return tecXCHAIN_CREATE_ACCOUNT_DISABLED;
+
2198  auto const sleBridge = readBridge(ctx.view, bridgeSpec);
+
2199  if (!sleBridge)
+
2200  {
+
2201  return tecNO_ENTRY;
+
2202  }
+
2203 
+
2204  if (reward != (*sleBridge)[sfSignatureReward])
+
2205  {
+
2206  return tecXCHAIN_REWARD_MISMATCH;
+
2207  }
2208 
-
2209  if (amount < *minCreateAmount)
-
2210  return tecXCHAIN_INSUFF_CREATE_AMOUNT;
+
2209  std::optional<STAmount> const minCreateAmount =
+
2210  (*sleBridge)[~sfMinAccountCreateAmount];
2211 
-
2212  if (minCreateAmount->issue() != amount.issue())
-
2213  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
2212  if (!minCreateAmount)
+
2213  return tecXCHAIN_CREATE_ACCOUNT_DISABLED;
2214 
-
2215  AccountID const thisDoor = (*sleBridge)[sfAccount];
-
2216  AccountID const account = ctx.tx[sfAccount];
-
2217  if (thisDoor == account)
-
2218  {
-
2219  // Door account can't lock funds onto itself
-
2220  return tecXCHAIN_SELF_COMMIT;
-
2221  }
-
2222 
-
2223  STXChainBridge::ChainType srcChain = STXChainBridge::ChainType::locking;
+
2215  if (amount < *minCreateAmount)
+
2216  return tecXCHAIN_INSUFF_CREATE_AMOUNT;
+
2217 
+
2218  if (minCreateAmount->issue() != amount.issue())
+
2219  return tecXCHAIN_BAD_TRANSFER_ISSUE;
+
2220 
+
2221  AccountID const thisDoor = (*sleBridge)[sfAccount];
+
2222  AccountID const account = ctx.tx[sfAccount];
+
2223  if (thisDoor == account)
2224  {
-
2225  if (thisDoor == bridgeSpec.lockingChainDoor())
-
2226  srcChain = STXChainBridge::ChainType::locking;
-
2227  else if (thisDoor == bridgeSpec.issuingChainDoor())
-
2228  srcChain = STXChainBridge::ChainType::issuing;
-
2229  else
-
2230  return tecINTERNAL;
-
2231  }
-
2232  STXChainBridge::ChainType const dstChain =
-
2233  STXChainBridge::otherChain(srcChain);
-
2234 
-
2235  if (bridgeSpec.issue(srcChain) != ctx.tx[sfAmount].issue())
-
2236  return tecXCHAIN_BAD_TRANSFER_ISSUE;
-
2237 
-
2238  if (!isXRP(bridgeSpec.issue(dstChain)))
-
2239  return tecXCHAIN_CREATE_ACCOUNT_NONXRP_ISSUE;
+
2225  // Door account can't lock funds onto itself
+
2226  return tecXCHAIN_SELF_COMMIT;
+
2227  }
+
2228 
+
2229  STXChainBridge::ChainType srcChain = STXChainBridge::ChainType::locking;
+
2230  {
+
2231  if (thisDoor == bridgeSpec.lockingChainDoor())
+
2232  srcChain = STXChainBridge::ChainType::locking;
+
2233  else if (thisDoor == bridgeSpec.issuingChainDoor())
+
2234  srcChain = STXChainBridge::ChainType::issuing;
+
2235  else
+
2236  return tecINTERNAL;
+
2237  }
+
2238  STXChainBridge::ChainType const dstChain =
+
2239  STXChainBridge::otherChain(srcChain);
2240 
-
2241  return tesSUCCESS;
-
2242 }
+
2241  if (bridgeSpec.issue(srcChain) != ctx.tx[sfAmount].issue())
+
2242  return tecXCHAIN_BAD_TRANSFER_ISSUE;
2243 
-
2244 TER
-
2245 XChainCreateAccountCommit::doApply()
-
2246 {
-
2247  PaymentSandbox psb(&ctx_.view());
-
2248 
-
2249  AccountID const account = ctx_.tx[sfAccount];
-
2250  STAmount const amount = ctx_.tx[sfAmount];
-
2251  STAmount const reward = ctx_.tx[sfSignatureReward];
-
2252  STXChainBridge const bridge = ctx_.tx[sfXChainBridge];
-
2253 
-
2254  auto const sle = psb.peek(keylet::account(account));
-
2255  if (!sle)
-
2256  return tecINTERNAL;
-
2257 
-
2258  auto const sleBridge = peekBridge(psb, bridge);
-
2259  if (!sleBridge)
-
2260  return tecINTERNAL;
-
2261 
-
2262  auto const dst = (*sleBridge)[sfAccount];
+
2244  if (!isXRP(bridgeSpec.issue(dstChain)))
+
2245  return tecXCHAIN_CREATE_ACCOUNT_NONXRP_ISSUE;
+
2246 
+
2247  return tesSUCCESS;
+
2248 }
+
2249 
+
2250 TER
+
2251 XChainCreateAccountCommit::doApply()
+
2252 {
+
2253  PaymentSandbox psb(&ctx_.view());
+
2254 
+
2255  AccountID const account = ctx_.tx[sfAccount];
+
2256  STAmount const amount = ctx_.tx[sfAmount];
+
2257  STAmount const reward = ctx_.tx[sfSignatureReward];
+
2258  STXChainBridge const bridge = ctx_.tx[sfXChainBridge];
+
2259 
+
2260  auto const sle = psb.peek(keylet::account(account));
+
2261  if (!sle)
+
2262  return tecINTERNAL;
2263 
-
2264  // Support dipping into reserves to pay the fee
-
2265  TransferHelperSubmittingAccountInfo submittingAccountInfo{
-
2266  account_, mPriorBalance, mSourceBalance};
-
2267  STAmount const toTransfer = amount + reward;
-
2268  auto const thTer = transferHelper(
-
2269  psb,
-
2270  account,
-
2271  dst,
-
2272  /*dstTag*/ std::nullopt,
-
2273  /*claimOwner*/ std::nullopt,
-
2274  toTransfer,
-
2275  CanCreateDstPolicy::yes,
-
2276  DepositAuthPolicy::normal,
-
2277  submittingAccountInfo,
-
2278  ctx_.journal);
-
2279 
-
2280  if (!isTesSuccess(thTer))
-
2281  return thTer;
-
2282 
-
2283  (*sleBridge)[sfXChainAccountCreateCount] =
-
2284  (*sleBridge)[sfXChainAccountCreateCount] + 1;
-
2285  psb.update(sleBridge);
-
2286 
-
2287  psb.apply(ctx_.rawView());
+
2264  auto const sleBridge = peekBridge(psb, bridge);
+
2265  if (!sleBridge)
+
2266  return tecINTERNAL;
+
2267 
+
2268  auto const dst = (*sleBridge)[sfAccount];
+
2269 
+
2270  // Support dipping into reserves to pay the fee
+
2271  TransferHelperSubmittingAccountInfo submittingAccountInfo{
+
2272  account_, mPriorBalance, mSourceBalance};
+
2273  STAmount const toTransfer = amount + reward;
+
2274  auto const thTer = transferHelper(
+
2275  psb,
+
2276  account,
+
2277  dst,
+
2278  /*dstTag*/ std::nullopt,
+
2279  /*claimOwner*/ std::nullopt,
+
2280  toTransfer,
+
2281  CanCreateDstPolicy::yes,
+
2282  DepositAuthPolicy::normal,
+
2283  submittingAccountInfo,
+
2284  ctx_.journal);
+
2285 
+
2286  if (!isTesSuccess(thTer))
+
2287  return thTer;
2288 
-
2289  return tesSUCCESS;
-
2290 }
-
2291 
-
2292 } // namespace ripple
+
2289  (*sleBridge)[sfXChainAccountCreateCount] =
+
2290  (*sleBridge)[sfXChainAccountCreateCount] + 1;
+
2291  psb.update(sleBridge);
+
2292 
+
2293  psb.apply(ctx_.rawView());
+
2294 
+
2295  return tesSUCCESS;
+
2296 }
+
2297 
+
2298 } // namespace ripple
beast::Journal::fatal
Stream fatal() const
Definition: Journal.h:338
-
ripple::XChainClaim::doApply
TER doApply() override
Definition: XChainBridge.cpp:1761
+
ripple::XChainClaim::doApply
TER doApply() override
Definition: XChainBridge.cpp:1767
ripple::temXCHAIN_BAD_PROOF
@ temXCHAIN_BAD_PROOF
Definition: TER.h:130
ripple::keylet::ownerDir
Keylet ownerDir(AccountID const &id) noexcept
The root page of an account's directory.
Definition: Indexes.cpp:311
ripple::tecXCHAIN_ACCOUNT_CREATE_TOO_MANY
@ tecXCHAIN_ACCOUNT_CREATE_TOO_MANY
Definition: TER.h:326
@@ -2310,10 +2316,10 @@ $(function() {
ripple::tecXCHAIN_SENDING_ACCOUNT_MISMATCH
@ tecXCHAIN_SENDING_ACCOUNT_MISMATCH
Definition: TER.h:323
ripple::temXCHAIN_EQUAL_DOOR_ACCOUNTS
@ temXCHAIN_EQUAL_DOOR_ACCOUNTS
Definition: TER.h:129
ripple::Unexpected
Unexpected(E(&)[N]) -> Unexpected< E const * >
-
ripple::XChainCreateClaimID::doApply
TER doApply() override
Definition: XChainBridge.cpp:2061
+
ripple::XChainCreateClaimID::doApply
TER doApply() override
Definition: XChainBridge.cpp:2067
ripple::tecDST_TAG_NEEDED
@ tecDST_TAG_NEEDED
Definition: TER.h:287
ripple::detail::ApplyViewBase::update
void update(std::shared_ptr< SLE > const &sle) override
Indicate changes to a peeked SLE.
Definition: ApplyViewBase.cpp:146
-
ripple::XChainCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1915
+
ripple::XChainCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1921
ripple::STXChainBridge::ChainType::locking
@ locking
ripple::sfOtherChainSource
const SF_ACCOUNT sfOtherChainSource
ripple::tecXCHAIN_NO_CLAIM_ID
@ tecXCHAIN_NO_CLAIM_ID
Definition: TER.h:315
@@ -2328,7 +2334,7 @@ $(function() {
ripple::sfXChainAccountClaimCount
const SF_UINT64 sfXChainAccountClaimCount
ripple::temBAD_ISSUER
@ temBAD_ISSUER
Definition: TER.h:91
ripple::lsfAllowTrustLineClawback
@ lsfAllowTrustLineClawback
Definition: LedgerFormats.h:272
-
ripple::XChainAddClaimAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2125
+
ripple::XChainAddClaimAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2131
ripple::isTecClaim
bool isTecClaim(TER x)
Definition: TER.h:639
ripple::temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT
@ temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT
Definition: TER.h:134
ripple::generateKeyPair
std::pair< PublicKey, SecretKey > generateKeyPair(KeyType type, Seed const &seed)
Generate a key pair deterministically.
Definition: SecretKey.cpp:351
@@ -2350,12 +2356,12 @@ $(function() {
ripple::XChainCreateBridge::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1367
ripple::tefBAD_LEDGER
@ tefBAD_LEDGER
Definition: TER.h:161
ripple::adjustOwnerCount
void adjustOwnerCount(ApplyView &view, std::shared_ptr< SLE > const &sle, std::int32_t amount, beast::Journal j)
Adjust the owner count up or down.
Definition: View.cpp:730
-
ripple::XChainCreateAccountCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2186
+
ripple::XChainCreateAccountCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2192
ripple::STXChainBridge::issuingChainIssue
Issue const & issuingChainIssue() const
Definition: STXChainBridge.h:182
ripple::Expected
Definition: Expected.h:132
ripple::sfSignatureReward
const SF_AMOUNT sfSignatureReward
ripple::keylet::account
Keylet account(AccountID const &id) noexcept
AccountID root.
Definition: Indexes.cpp:141
-
ripple::XChainCreateAccountCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2159
+
ripple::XChainCreateAccountCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2165
ripple::sfXChainClaimAttestations
const SField sfXChainClaimAttestations
ripple::tecDUPLICATE
@ tecDUPLICATE
Definition: TER.h:293
ripple::keylet::bridge
Keylet bridge(STXChainBridge const &bridge, STXChainBridge::ChainType chainType)
Definition: Indexes.cpp:400
@@ -2364,7 +2370,7 @@ $(function() {
ripple::isTefFailure
bool isTefFailure(TER x)
Definition: TER.h:621
ripple::XChainCreateBridge::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1451
ripple::calcAccountID
AccountID calcAccountID(PublicKey const &pk)
Definition: AccountID.cpp:158
-
ripple::XChainCreateClaimID::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2004
+
ripple::XChainCreateClaimID::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2010
ripple::STArray
Definition: STArray.h:28
ripple::flow
path::RippleCalc::Output flow(PaymentSandbox &sb, STAmount const &deliver, AccountID const &src, AccountID const &dst, STPathSet const &paths, bool defaultPaths, bool partialPayment, bool ownerPaysTransferFee, bool offerCrossing, std::optional< Quality > const &limitQuality, std::optional< STAmount > const &sendMax, beast::Journal j, path::detail::FlowDebugInfo *flowDebugInfo)
Make a payment from the src account to the dst account.
Definition: Flow.cpp:59
ripple::TER
TERSubset< CanCvtToTER > TER
Definition: TER.h:604
@@ -2374,7 +2380,7 @@ $(function() {
ripple::ReadView::exists
virtual bool exists(Keylet const &k) const =0
Determine if a state item exists.
ripple::tecINTERNAL
@ tecINTERNAL
Definition: TER.h:288
ripple::STObject::getFlags
std::uint32_t getFlags() const
Definition: STObject.cpp:481
-
ripple::XChainClaim::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1677
+
ripple::XChainClaim::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1683
ripple::isXRP
bool isXRP(AccountID const &c)
Definition: AccountID.h:91
ripple::tecXCHAIN_PAYMENT_FAILED
@ tecXCHAIN_PAYMENT_FAILED
Definition: TER.h:327
ripple::temBAD_AMOUNT
@ temBAD_AMOUNT
Definition: TER.h:87
@@ -2387,7 +2393,7 @@ $(function() {
ripple::XChainClaimAttestations
Definition: XChainAttestations.h:488
ripple::featureXChainBridge
const uint256 featureXChainBridge
ripple::ReadView::read
virtual std::shared_ptr< SLE const > read(Keylet const &k) const =0
Return the state item associated with a key.
-
ripple::BridgeModify::doApply
TER doApply() override
Definition: XChainBridge.cpp:1612
+
ripple::BridgeModify::doApply
TER doApply() override
Definition: XChainBridge.cpp:1618
ripple::ApplyContext::view
ApplyView & view()
Definition: ApplyContext.h:54
ripple::STXChainBridge::lockingChainDoor
AccountID const & lockingChainDoor() const
Definition: STXChainBridge.h:164
ripple::PreclaimContext::tx
STTx const & tx
Definition: Transactor.h:58
@@ -2403,31 +2409,31 @@ $(function() {
ripple::sfMinAccountCreateAmount
const SF_AMOUNT sfMinAccountCreateAmount
ripple::ApplyView::insert
virtual void insert(std::shared_ptr< SLE > const &sle)=0
Insert a new state SLE.
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
-
ripple::XChainCreateClaimID::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2024
+
ripple::XChainCreateClaimID::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2030
ripple::tfClearAccountCreateAmount
constexpr std::uint32_t tfClearAccountCreateAmount
Definition: TxFlags.h:185
-
ripple::XChainCreateAccountCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:2245
+
ripple::XChainCreateAccountCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:2251
ripple::tecXCHAIN_CREATE_ACCOUNT_DISABLED
@ tecXCHAIN_CREATE_ACCOUNT_DISABLED
Definition: TER.h:330
ripple::ltBRIDGE
@ ltBRIDGE
The ledger object which lists details about sidechains.
Definition: LedgerFormats.h:99
ripple::tecXCHAIN_SELF_COMMIT
@ tecXCHAIN_SELF_COMMIT
Definition: TER.h:328
ripple::temDISABLED
@ temDISABLED
Definition: TER.h:112
ripple::PaymentSandbox::apply
void apply(RawView &to)
Apply changes to base view.
Definition: PaymentSandbox.cpp:254
ripple::Fees::accountReserve
XRPAmount accountReserve(std::size_t ownerCount) const
Returns the account reserve given the owner count, in drops.
Definition: protocol/Fees.h:49
-
ripple::XChainAddAccountCreateAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2145
+
ripple::XChainAddAccountCreateAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2151
ripple::tecXCHAIN_REWARD_MISMATCH
@ tecXCHAIN_REWARD_MISMATCH
Definition: TER.h:321
ripple::sfFlags
const SF_UINT32 sfFlags
-
ripple::XChainCommit::makeTxConsequences
static TxConsequences makeTxConsequences(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1877
+
ripple::XChainCommit::makeTxConsequences
static TxConsequences makeTxConsequences(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1883
ripple::tecNO_ISSUER
@ tecNO_ISSUER
Definition: TER.h:277
ripple::sfDestinationTag
const SF_UINT32 sfDestinationTag
-
ripple::XChainCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:1960
+
ripple::XChainCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:1966
ripple::Transactor::mPriorBalance
XRPAmount mPriorBalance
Definition: Transactor.h:92
ripple::tecNO_PERMISSION
@ tecNO_PERMISSION
Definition: TER.h:283
ripple::Transactor::mSourceBalance
XRPAmount mSourceBalance
Definition: Transactor.h:93
-
ripple::XChainAddClaimAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2131
+
ripple::XChainAddClaimAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2137
ripple::sfXChainAccountCreateCount
const SF_UINT64 sfXChainAccountCreateCount
ripple::sfBalance
const SF_AMOUNT sfBalance
-
ripple::XChainCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1890
-
ripple::XChainCreateBridge::doApply
TER doApply() override
Definition: XChainBridge.cpp:1496
-
ripple::XChainAddAccountCreateAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2151
+
ripple::XChainCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1896
+
ripple::XChainCreateBridge::doApply
TER doApply() override
Definition: XChainBridge.cpp:1502
+
ripple::XChainAddAccountCreateAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2157
ripple::keylet::xChainCreateAccountClaimID
Keylet xChainCreateAccountClaimID(STXChainBridge const &bridge, std::uint64_t seq)
Definition: Indexes.cpp:427
ripple::tecINSUFFICIENT_RESERVE
@ tecINSUFFICIENT_RESERVE
Definition: TER.h:285
std::vector::empty
T empty(T... args)
@@ -2435,8 +2441,8 @@ $(function() {
ripple::Transactor::ctx_
ApplyContext & ctx_
Definition: Transactor.h:88
ripple::AttestationMatch
AttestationMatch
Definition: XChainAttestations.h:258
std::optional
-
ripple::XChainAddClaimAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2119
-
ripple::BridgeModify::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1595
+
ripple::XChainAddClaimAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2125
+
ripple::BridgeModify::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1601
ripple::temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT
@ temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT
Definition: TER.h:133
ripple::detail::ApplyViewBase::read
std::shared_ptr< SLE const > read(Keylet const &k) const override
Return the state item associated with a key.
Definition: ApplyViewBase.cpp:71
ripple::sfAccount
const SF_ACCOUNT sfAccount
@@ -2449,10 +2455,10 @@ $(function() {
std::numeric_limits::max
T max(T... args)
ripple::PreflightContext
State information when preflighting a tx.
Definition: Transactor.h:31
ripple::keylet::signers
static Keylet signers(AccountID const &account, std::uint32_t page) noexcept
Definition: Indexes.cpp:276
-
ripple::XChainClaim::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1652
+
ripple::XChainClaim::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1658
ripple::ApplyView::dirInsert
std::optional< std::uint64_t > dirInsert(Keylet const &directory, uint256 const &key, std::function< void(std::shared_ptr< SLE > const &)> const &describe)
Insert an entry to a directory.
Definition: ApplyView.h:306
ripple::PreflightContext::rules
const Rules rules
Definition: Transactor.h:36
-
ripple::BridgeModify::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1542
+
ripple::BridgeModify::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1548
ripple::tfUniversalMask
constexpr std::uint32_t tfUniversalMask
Definition: TxFlags.h:60
unordered_map
ripple::keylet::depositPreauth
Keylet depositPreauth(AccountID const &owner, AccountID const &preauthorized) noexcept
A DepositPreauth.
Definition: Indexes.cpp:295
@@ -2466,7 +2472,7 @@ $(function() {
ripple::ApplyContext::tx
STTx const & tx
Definition: ApplyContext.h:48
ripple::AccountID
base_uint< 160, detail::AccountIDTag > AccountID
A 160-bit unsigned that uniquely identifies an account.
Definition: AccountID.h:49
ripple::tecNO_DST
@ tecNO_DST
Definition: TER.h:268
-
ripple::XChainAddAccountCreateAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2139
+
ripple::XChainAddAccountCreateAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2145
ripple::XRPAmount
Definition: XRPAmount.h:46
ripple::NotTEC
TERSubset< CanCvtToNotTEC > NotTEC
Definition: TER.h:564
ripple::tecXCHAIN_INSUFF_CREATE_AMOUNT
@ tecXCHAIN_INSUFF_CREATE_AMOUNT
Definition: TER.h:324
diff --git a/XChainBridge_8h_source.html b/XChainBridge_8h_source.html index 888caf3001..5ee1bd751a 100644 --- a/XChainBridge_8h_source.html +++ b/XChainBridge_8h_source.html @@ -325,7 +325,7 @@ $(function() {
254 
255 #endif
-
ripple::XChainClaim::doApply
TER doApply() override
Definition: XChainBridge.cpp:1761
+
ripple::XChainClaim::doApply
TER doApply() override
Definition: XChainBridge.cpp:1767
ripple::Transactor::Blocker
@ Blocker
Definition: Transactor.h:101
ripple::XChainClaim
Definition: XChainBridge.h:81
ripple::XChainCommit::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:109
@@ -334,26 +334,26 @@ $(function() {
ripple::XChainCreateBridge::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:36
ripple::XChainCreateAccountCommit::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:235
ripple::XChainCreateClaimID::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:141
-
ripple::XChainCreateClaimID::doApply
TER doApply() override
Definition: XChainBridge.cpp:2061
-
ripple::XChainCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1915
+
ripple::XChainCreateClaimID::doApply
TER doApply() override
Definition: XChainBridge.cpp:2067
+
ripple::XChainCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1921
ripple::BridgeModify
Definition: XChainBridge.h:52
ripple::XChainCreateAccountCommit::XChainCreateAccountCommit
XChainCreateAccountCommit(ApplyContext &ctx)
Definition: XChainBridge.h:237
ripple::XChainCommit::XChainCommit
XChainCommit(ApplyContext &ctx)
Definition: XChainBridge.h:114
ripple::XChainCommit
Definition: XChainBridge.h:106
-
ripple::XChainAddClaimAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2125
+
ripple::XChainAddClaimAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2131
ripple::XChainCreateBridge::XChainCreateBridge
XChainCreateBridge(ApplyContext &ctx)
Definition: XChainBridge.h:38
ripple::XChainCreateBridge::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1367
-
ripple::XChainCreateAccountCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2186
+
ripple::XChainCreateAccountCommit::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2192
ripple::Transactor::ConsequencesFactoryType
ConsequencesFactoryType
Definition: Transactor.h:101
ripple::XChainClaim::XChainClaim
XChainClaim(ApplyContext &ctx)
Definition: XChainBridge.h:87
-
ripple::XChainCreateAccountCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2159
+
ripple::XChainCreateAccountCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2165
ripple::TERSubset
Definition: TER.h:376
ripple::XChainCreateBridge::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1451
-
ripple::XChainCreateClaimID::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2004
-
ripple::XChainClaim::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1677
+
ripple::XChainCreateClaimID::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2010
+
ripple::XChainClaim::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1683
ripple::ApplyContext
State information when applying a tx.
Definition: ApplyContext.h:35
ripple::XChainAddAccountCreateAttestation::XChainAddAccountCreateAttestation
XChainAddAccountCreateAttestation(ApplyContext &ctx)
Definition: XChainBridge.h:192
-
ripple::BridgeModify::doApply
TER doApply() override
Definition: XChainBridge.cpp:1612
+
ripple::BridgeModify::doApply
TER doApply() override
Definition: XChainBridge.cpp:1618
ripple::XChainClaim::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:85
ripple::XChainAddClaimAttestation::XChainAddClaimAttestation
XChainAddClaimAttestation(ApplyContext &ctx)
Definition: XChainBridge.h:172
ripple::BridgeModify::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:55
@@ -364,28 +364,28 @@ $(function() {
ripple::Transactor::Custom
@ Custom
Definition: Transactor.h:101
ripple::xbridgeMaxAccountCreateClaims
constexpr size_t xbridgeMaxAccountCreateClaims
Definition: XChainBridge.h:29
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
-
ripple::XChainCreateClaimID::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2024
-
ripple::XChainCreateAccountCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:2245
+
ripple::XChainCreateClaimID::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2030
+
ripple::XChainCreateAccountCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:2251
ripple::XChainAddAccountCreateAttestation::ConsequencesFactory
static constexpr ConsequencesFactoryType ConsequencesFactory
Definition: XChainBridge.h:190
-
ripple::XChainAddAccountCreateAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2145
+
ripple::XChainAddAccountCreateAttestation::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:2151
ripple::XChainCreateClaimID
Definition: XChainBridge.h:138
ripple::Transactor::Normal
@ Normal
Definition: Transactor.h:101
-
ripple::XChainCommit::makeTxConsequences
static TxConsequences makeTxConsequences(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1877
-
ripple::XChainCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:1960
+
ripple::XChainCommit::makeTxConsequences
static TxConsequences makeTxConsequences(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1883
+
ripple::XChainCommit::doApply
TER doApply() override
Definition: XChainBridge.cpp:1966
ripple::XChainCreateClaimID::XChainCreateClaimID
XChainCreateClaimID(ApplyContext &ctx)
Definition: XChainBridge.h:143
-
ripple::XChainAddClaimAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2131
-
ripple::XChainCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1890
-
ripple::XChainCreateBridge::doApply
TER doApply() override
Definition: XChainBridge.cpp:1496
-
ripple::XChainAddAccountCreateAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2151
-
ripple::XChainAddClaimAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2119
-
ripple::BridgeModify::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1595
+
ripple::XChainAddClaimAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2137
+
ripple::XChainCommit::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1896
+
ripple::XChainCreateBridge::doApply
TER doApply() override
Definition: XChainBridge.cpp:1502
+
ripple::XChainAddAccountCreateAttestation::doApply
TER doApply() override
Definition: XChainBridge.cpp:2157
+
ripple::XChainAddClaimAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2125
+
ripple::BridgeModify::preclaim
static TER preclaim(PreclaimContext const &ctx)
Definition: XChainBridge.cpp:1601
ripple::XChainCreateAccountCommit
Definition: XChainBridge.h:232
ripple::PreflightContext
State information when preflighting a tx.
Definition: Transactor.h:31
ripple::XChainAddClaimAttestation
Definition: XChainBridge.h:166
-
ripple::XChainClaim::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1652
-
ripple::BridgeModify::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1542
+
ripple::XChainClaim::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1658
+
ripple::BridgeModify::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:1548
ripple::TxConsequences
Class describing the consequences to the account of applying a transaction if the transaction consume...
Definition: applySteps.h:45
-
ripple::XChainAddAccountCreateAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2139
+
ripple::XChainAddAccountCreateAttestation::preflight
static NotTEC preflight(PreflightContext const &ctx)
Definition: XChainBridge.cpp:2145
Generated by   diff --git a/XChain__test_8cpp_source.html b/XChain__test_8cpp_source.html index b496eac88c..6926f2a457 100644 --- a/XChain__test_8cpp_source.html +++ b/XChain__test_8cpp_source.html @@ -543,4614 +543,4626 @@ $(function() {
472  mcBob, bridge(mcBob, mcGw["USD"], mcBob, mcGw["USD"])),
473  ter(temXCHAIN_EQUAL_DOOR_ACCOUNTS));
474 
-
475  // Both door accounts are on the same chain is allowed (they likely
-
476  // belong to different chains. If they do belong to the same chain, that
-
477  // is silly, but doesn't violate any invariants).
+
475  // Both door accounts are on the same chain. This is not allowed.
+
476  // Although it doesn't violate any invariants, it's not a useful thing
+
477  // to do and it complicates the "add claim" transactions.
478  XEnv(*this)
479  .tx(create_bridge(
480  mcAlice, bridge(mcAlice, mcGw["USD"], mcBob, mcBob["USD"])))
481  .close()
482  .tx(create_bridge(
-
483  mcBob, bridge(mcAlice, mcGw["USD"], mcBob, mcBob["USD"])))
-
484  .close();
-
485 
-
486  // Create a bridge on an account with exactly enough balance to
-
487  // meet the new reserve should succeed
-
488  XEnv(*this)
-
489  .fund(res1, mcuDoor) // exact reserve for account + 1 object
-
490  .close()
-
491  .tx(create_bridge(mcuDoor, jvub), ter(tesSUCCESS));
-
492 
-
493  // Create a bridge on an account with no enough balance to meet the
-
494  // new reserve
-
495  XEnv(*this)
-
496  .fund(res1 - 1, mcuDoor) // just short of required reserve
-
497  .close()
-
498  .tx(create_bridge(mcuDoor, jvub), ter(tecINSUFFICIENT_RESERVE));
-
499 
-
500  // Reward amount is non-xrp
-
501  XEnv(*this).tx(
-
502  create_bridge(mcDoor, jvb, mcUSD(1)),
-
503  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
-
504 
-
505  // Reward amount is XRP and negative
-
506  XEnv(*this).tx(
-
507  create_bridge(mcDoor, jvb, XRP(-1)),
-
508  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
-
509 
-
510  // Reward amount is 1 xrp => should succeed
-
511  XEnv(*this).tx(create_bridge(mcDoor, jvb, XRP(1)), ter(tesSUCCESS));
-
512 
-
513  // Min create amount is 1 xrp, mincreate is 1 xrp => should succeed
-
514  XEnv(*this).tx(
-
515  create_bridge(mcDoor, jvb, XRP(1), XRP(1)), ter(tesSUCCESS));
-
516 
-
517  // Min create amount is non-xrp
-
518  XEnv(*this).tx(
-
519  create_bridge(mcDoor, jvb, XRP(1), mcUSD(100)),
-
520  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
-
521 
-
522  // Min create amount is zero (should fail, currently succeeds)
-
523  XEnv(*this).tx(
-
524  create_bridge(mcDoor, jvb, XRP(1), XRP(0)),
-
525  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
-
526 
-
527  // Min create amount is negative
-
528  XEnv(*this).tx(
-
529  create_bridge(mcDoor, jvb, XRP(1), XRP(-1)),
-
530  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
-
531 
-
532  // coverage test: BridgeCreate::preflight() - create bridge when feature
-
533  // disabled.
-
534  {
-
535  Env env(*this, supported_amendments() - featureXChainBridge);
-
536  env(create_bridge(Account::master, jvb), ter(temDISABLED));
-
537  }
-
538 
-
539  // coverage test: BridgeCreate::preclaim() returns tecNO_ISSUER.
-
540  XEnv(*this).tx(
-
541  create_bridge(
-
542  mcAlice, bridge(mcAlice, mcuAlice["USD"], mcBob, mcBob["USD"])),
-
543  ter(tecNO_ISSUER));
-
544 
-
545  // coverage test: create_bridge transaction with incorrect flag
-
546  XEnv(*this).tx(
-
547  create_bridge(mcAlice, jvb),
-
548  txflags(tfFillOrKill),
-
549  ter(temINVALID_FLAG));
-
550 
-
551  // coverage test: create_bridge transaction with xchain feature disabled
-
552  XEnv(*this)
-
553  .disableFeature(featureXChainBridge)
-
554  .tx(create_bridge(mcAlice, jvb), ter(temDISABLED));
-
555  }
-
556 
-
557  void
-
558  testXChainBridgeCreateConstraints()
-
559  {
-
605  using namespace jtx;
-
606  testcase("Bridge create constraints");
-
607  XEnv env(*this, true);
-
608  auto& A = scAlice;
-
609  auto& B = scBob;
-
610  auto& C = scCarol;
-
611  auto AUSD = A["USD"];
-
612  auto BUSD = B["USD"];
-
613  auto CUSD = C["USD"];
-
614  auto GUSD = scGw["USD"];
-
615  auto AEUR = A["EUR"];
-
616  auto BEUR = B["EUR"];
-
617  auto CEUR = C["EUR"];
-
618  auto GEUR = scGw["EUR"];
-
619 
-
620  // Accounts to own single brdiges
-
621  Account const a1("a1");
-
622  Account const a2("a2");
-
623  Account const a3("a3");
-
624  Account const a4("a4");
-
625 
-
626  env.fund(XRP(10000), a1, a2, a3, a4);
-
627  env.close();
+
483  mcBob, bridge(mcAlice, mcGw["USD"], mcBob, mcBob["USD"])),
+
484  ter(tecDUPLICATE))
+
485  .close();
+
486 
+
487  // Create a bridge on an account with exactly enough balance to
+
488  // meet the new reserve should succeed
+
489  XEnv(*this)
+
490  .fund(res1, mcuDoor) // exact reserve for account + 1 object
+
491  .close()
+
492  .tx(create_bridge(mcuDoor, jvub), ter(tesSUCCESS));
+
493 
+
494  // Create a bridge on an account with no enough balance to meet the
+
495  // new reserve
+
496  XEnv(*this)
+
497  .fund(res1 - 1, mcuDoor) // just short of required reserve
+
498  .close()
+
499  .tx(create_bridge(mcuDoor, jvub), ter(tecINSUFFICIENT_RESERVE));
+
500 
+
501  // Reward amount is non-xrp
+
502  XEnv(*this).tx(
+
503  create_bridge(mcDoor, jvb, mcUSD(1)),
+
504  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
+
505 
+
506  // Reward amount is XRP and negative
+
507  XEnv(*this).tx(
+
508  create_bridge(mcDoor, jvb, XRP(-1)),
+
509  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
+
510 
+
511  // Reward amount is 1 xrp => should succeed
+
512  XEnv(*this).tx(create_bridge(mcDoor, jvb, XRP(1)), ter(tesSUCCESS));
+
513 
+
514  // Min create amount is 1 xrp, mincreate is 1 xrp => should succeed
+
515  XEnv(*this).tx(
+
516  create_bridge(mcDoor, jvb, XRP(1), XRP(1)), ter(tesSUCCESS));
+
517 
+
518  // Min create amount is non-xrp
+
519  XEnv(*this).tx(
+
520  create_bridge(mcDoor, jvb, XRP(1), mcUSD(100)),
+
521  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
+
522 
+
523  // Min create amount is zero (should fail, currently succeeds)
+
524  XEnv(*this).tx(
+
525  create_bridge(mcDoor, jvb, XRP(1), XRP(0)),
+
526  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
+
527 
+
528  // Min create amount is negative
+
529  XEnv(*this).tx(
+
530  create_bridge(mcDoor, jvb, XRP(1), XRP(-1)),
+
531  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
+
532 
+
533  // coverage test: BridgeCreate::preflight() - create bridge when feature
+
534  // disabled.
+
535  {
+
536  Env env(*this, supported_amendments() - featureXChainBridge);
+
537  env(create_bridge(Account::master, jvb), ter(temDISABLED));
+
538  }
+
539 
+
540  // coverage test: BridgeCreate::preclaim() returns tecNO_ISSUER.
+
541  XEnv(*this).tx(
+
542  create_bridge(
+
543  mcAlice, bridge(mcAlice, mcuAlice["USD"], mcBob, mcBob["USD"])),
+
544  ter(tecNO_ISSUER));
+
545 
+
546  // coverage test: create_bridge transaction with incorrect flag
+
547  XEnv(*this).tx(
+
548  create_bridge(mcAlice, jvb),
+
549  txflags(tfFillOrKill),
+
550  ter(temINVALID_FLAG));
+
551 
+
552  // coverage test: create_bridge transaction with xchain feature disabled
+
553  XEnv(*this)
+
554  .disableFeature(featureXChainBridge)
+
555  .tx(create_bridge(mcAlice, jvb), ter(temDISABLED));
+
556  }
+
557 
+
558  void
+
559  testXChainBridgeCreateConstraints()
+
560  {
+
606  using namespace jtx;
+
607  testcase("Bridge create constraints");
+
608  XEnv env(*this, true);
+
609  auto& A = scAlice;
+
610  auto& B = scBob;
+
611  auto& C = scCarol;
+
612  auto AUSD = A["USD"];
+
613  auto BUSD = B["USD"];
+
614  auto CUSD = C["USD"];
+
615  auto GUSD = scGw["USD"];
+
616  auto AEUR = A["EUR"];
+
617  auto BEUR = B["EUR"];
+
618  auto CEUR = C["EUR"];
+
619  auto GEUR = scGw["EUR"];
+
620 
+
621  // Accounts to own single brdiges
+
622  Account const a1("a1");
+
623  Account const a2("a2");
+
624  Account const a3("a3");
+
625  Account const a4("a4");
+
626  Account const a5("a5");
+
627  Account const a6("a6");
628 
-
629  // Add a bridge on two different accounts with the same locking and
-
630  // issuing assets
-
631  env.tx(create_bridge(a1, bridge(a1, GUSD, B, BUSD))).close();
-
632  env.tx(create_bridge(a2, bridge(a2, GUSD, B, BUSD))).close();
-
633 
-
634  // Add the exact same bridge to two different accoutns (one must locking
-
635  // account and one must be issuing)
-
636  env.tx(create_bridge(a3, bridge(a3, GUSD, a4, a4["USD"]))).close();
-
637  env.tx(create_bridge(a4, bridge(a3, GUSD, a4, a4["USD"]))).close();
-
638 
-
639  // Test case 1 ~ 5, create bridges
-
640  auto const goodBridge1 = bridge(A, GUSD, B, BUSD);
-
641  auto const goodBridge2 = bridge(A, BUSD, C, CUSD);
-
642  env.tx(create_bridge(B, goodBridge1)).close();
-
643  // Issuing asset is the same, this is a duplicate
-
644  env.tx(create_bridge(B, bridge(A, GEUR, B, BUSD)), ter(tecDUPLICATE))
-
645  .close();
-
646  env.tx(create_bridge(A, goodBridge2), ter(tesSUCCESS)).close();
-
647  // Locking asset is the same - this is a duplicate
-
648  env.tx(create_bridge(A, bridge(A, BUSD, B, BEUR)), ter(tecDUPLICATE))
+
629  env.fund(XRP(10000), a1, a2, a3, a4, a5, a6);
+
630  env.close();
+
631 
+
632  // Add a bridge on two different accounts with the same locking and
+
633  // issuing assets
+
634  env.tx(create_bridge(a1, bridge(a1, GUSD, B, BUSD))).close();
+
635  env.tx(create_bridge(a2, bridge(a2, GUSD, B, BUSD))).close();
+
636 
+
637  // Add the exact same bridge to two different accounts (one locking
+
638  // account and one issuing)
+
639  env.tx(create_bridge(a3, bridge(a3, GUSD, a4, a4["USD"]))).close();
+
640  env.tx(create_bridge(a4, bridge(a3, GUSD, a4, a4["USD"])),
+
641  ter(tecDUPLICATE))
+
642  .close();
+
643 
+
644  // Add the exact same bridge to two different accounts (one issuing
+
645  // account and one locking - opposite order from the test above)
+
646  env.tx(create_bridge(a5, bridge(a6, GUSD, a5, a5["USD"]))).close();
+
647  env.tx(create_bridge(a6, bridge(a6, GUSD, a5, a5["USD"])),
+
648  ter(tecDUPLICATE))
649  .close();
-
650  // Locking asset is USD - this is a duplicate even tho it has a
-
651  // different issuer
-
652  env.tx(create_bridge(A, bridge(A, CUSD, B, BEUR)), ter(tecDUPLICATE))
-
653  .close();
-
654 
-
655  // Test case 6 and 7, commits
-
656  env.tx(trust(C, BUSD(1000)))
-
657  .tx(trust(A, BUSD(1000)))
-
658  .close()
-
659  .tx(pay(B, C, BUSD(1000)))
-
660  .close();
-
661  auto const aBalanceStart = env.balance(A, BUSD);
-
662  auto const cBalanceStart = env.balance(C, BUSD);
-
663  env.tx(xchain_commit(C, goodBridge1, 1, BUSD(50))).close();
-
664  BEAST_EXPECT(env.balance(A, BUSD) - aBalanceStart == BUSD(0));
-
665  BEAST_EXPECT(env.balance(C, BUSD) - cBalanceStart == BUSD(-50));
-
666  env.tx(xchain_commit(C, goodBridge2, 1, BUSD(60))).close();
-
667  BEAST_EXPECT(env.balance(A, BUSD) - aBalanceStart == BUSD(60));
-
668  BEAST_EXPECT(env.balance(C, BUSD) - cBalanceStart == BUSD(-50 - 60));
-
669 
-
670  // bridge modify test cases
-
671  env.tx(bridge_modify(B, goodBridge1, XRP(33), std::nullopt)).close();
-
672  BEAST_EXPECT((*env.bridge(goodBridge1))[sfSignatureReward] == XRP(33));
-
673  env.tx(bridge_modify(A, goodBridge2, XRP(44), std::nullopt)).close();
-
674  BEAST_EXPECT((*env.bridge(goodBridge2))[sfSignatureReward] == XRP(44));
-
675  }
-
676 
-
677  void
-
678  testXChainCreateBridgeMatrix()
-
679  {
-
680  using namespace jtx;
-
681  testcase("Create Bridge Matrix");
-
682 
-
683  // Test all combinations of the following:`
-
684  // --------------------------------------
-
685  // - Locking chain is IOU with locking chain door account as issuer
-
686  // - Locking chain is IOU with issuing chain door account that
-
687  // exists on the locking chain as issuer
-
688  // - Locking chain is IOU with issuing chain door account that does
-
689  // not exists on the locking chain as issuer
-
690  // - Locking chain is IOU with non-door account (that exists on the
-
691  // locking chain ledger) as issuer
-
692  // - Locking chain is IOU with non-door account (that does not exist
-
693  // exists on the locking chain ledger) as issuer
-
694  // - Locking chain is XRP
-
695  // ---------------------------------------------------------------------
-
696  // - Issuing chain is IOU with issuing chain door account as the
-
697  // issuer
-
698  // - Issuing chain is IOU with locking chain door account (that
-
699  // exists on the issuing chain ledger) as the issuer
-
700  // - Issuing chain is IOU with locking chain door account (that does
-
701  // not exist on the issuing chain ledger) as the issuer
-
702  // - Issuing chain is IOU with non-door account (that exists on the
-
703  // issuing chain ledger) as the issuer
-
704  // - Issuing chain is IOU with non-door account (that does not
-
705  // exists on the issuing chain ledger) as the issuer
-
706  // - Issuing chain is XRP and issuing chain door account is not the
-
707  // root account
-
708  // - Issuing chain is XRP and issuing chain door account is the root
-
709  // account
-
710  // ---------------------------------------------------------------------
-
711  // That's 42 combinations. The only combinations that should succeed
-
712  // are:
-
713  // - Locking chain is any IOU,
-
714  // - Issuing chain is IOU with issuing chain door account as the
-
715  // issuer
-
716  // Locking chain is XRP,
-
717  // - Issuing chain is XRP with issuing chain is the root account.
-
718  // ---------------------------------------------------------------------
-
719  Account a, b;
-
720  Issue ia, ib;
-
721 
-
722  std::tuple lcs{
-
723  std::make_pair(
-
724  "Locking chain is IOU(locking chain door)",
-
725  [&](auto& env, bool) {
-
726  a = mcDoor;
-
727  ia = mcDoor["USD"];
-
728  }),
-
729  std::make_pair(
-
730  "Locking chain is IOU(issuing chain door funded on locking "
-
731  "chain)",
-
732  [&](auto& env, bool shouldFund) {
-
733  a = mcDoor;
-
734  ia = scDoor["USD"];
-
735  if (shouldFund)
-
736  env.fund(XRP(10000), scDoor);
-
737  }),
-
738  std::make_pair(
-
739  "Locking chain is IOU(issuing chain door account unfunded "
-
740  "on locking chain)",
-
741  [&](auto& env, bool) {
-
742  a = mcDoor;
-
743  ia = scDoor["USD"];
-
744  }),
-
745  std::make_pair(
-
746  "Locking chain is IOU(bob funded on locking chain)",
-
747  [&](auto& env, bool) {
-
748  a = mcDoor;
-
749  ia = mcGw["USD"];
-
750  }),
-
751  std::make_pair(
-
752  "Locking chain is IOU(bob unfunded on locking chain)",
+
650 
+
651  // Test case 1 ~ 5, create bridges
+
652  auto const goodBridge1 = bridge(A, GUSD, B, BUSD);
+
653  auto const goodBridge2 = bridge(A, BUSD, C, CUSD);
+
654  env.tx(create_bridge(B, goodBridge1)).close();
+
655  // Issuing asset is the same, this is a duplicate
+
656  env.tx(create_bridge(B, bridge(A, GEUR, B, BUSD)), ter(tecDUPLICATE))
+
657  .close();
+
658  env.tx(create_bridge(A, goodBridge2), ter(tesSUCCESS)).close();
+
659  // Locking asset is the same - this is a duplicate
+
660  env.tx(create_bridge(A, bridge(A, BUSD, B, BEUR)), ter(tecDUPLICATE))
+
661  .close();
+
662  // Locking asset is USD - this is a duplicate even tho it has a
+
663  // different issuer
+
664  env.tx(create_bridge(A, bridge(A, CUSD, B, BEUR)), ter(tecDUPLICATE))
+
665  .close();
+
666 
+
667  // Test case 6 and 7, commits
+
668  env.tx(trust(C, BUSD(1000)))
+
669  .tx(trust(A, BUSD(1000)))
+
670  .close()
+
671  .tx(pay(B, C, BUSD(1000)))
+
672  .close();
+
673  auto const aBalanceStart = env.balance(A, BUSD);
+
674  auto const cBalanceStart = env.balance(C, BUSD);
+
675  env.tx(xchain_commit(C, goodBridge1, 1, BUSD(50))).close();
+
676  BEAST_EXPECT(env.balance(A, BUSD) - aBalanceStart == BUSD(0));
+
677  BEAST_EXPECT(env.balance(C, BUSD) - cBalanceStart == BUSD(-50));
+
678  env.tx(xchain_commit(C, goodBridge2, 1, BUSD(60))).close();
+
679  BEAST_EXPECT(env.balance(A, BUSD) - aBalanceStart == BUSD(60));
+
680  BEAST_EXPECT(env.balance(C, BUSD) - cBalanceStart == BUSD(-50 - 60));
+
681 
+
682  // bridge modify test cases
+
683  env.tx(bridge_modify(B, goodBridge1, XRP(33), std::nullopt)).close();
+
684  BEAST_EXPECT((*env.bridge(goodBridge1))[sfSignatureReward] == XRP(33));
+
685  env.tx(bridge_modify(A, goodBridge2, XRP(44), std::nullopt)).close();
+
686  BEAST_EXPECT((*env.bridge(goodBridge2))[sfSignatureReward] == XRP(44));
+
687  }
+
688 
+
689  void
+
690  testXChainCreateBridgeMatrix()
+
691  {
+
692  using namespace jtx;
+
693  testcase("Create Bridge Matrix");
+
694 
+
695  // Test all combinations of the following:`
+
696  // --------------------------------------
+
697  // - Locking chain is IOU with locking chain door account as issuer
+
698  // - Locking chain is IOU with issuing chain door account that
+
699  // exists on the locking chain as issuer
+
700  // - Locking chain is IOU with issuing chain door account that does
+
701  // not exists on the locking chain as issuer
+
702  // - Locking chain is IOU with non-door account (that exists on the
+
703  // locking chain ledger) as issuer
+
704  // - Locking chain is IOU with non-door account (that does not exist
+
705  // exists on the locking chain ledger) as issuer
+
706  // - Locking chain is XRP
+
707  // ---------------------------------------------------------------------
+
708  // - Issuing chain is IOU with issuing chain door account as the
+
709  // issuer
+
710  // - Issuing chain is IOU with locking chain door account (that
+
711  // exists on the issuing chain ledger) as the issuer
+
712  // - Issuing chain is IOU with locking chain door account (that does
+
713  // not exist on the issuing chain ledger) as the issuer
+
714  // - Issuing chain is IOU with non-door account (that exists on the
+
715  // issuing chain ledger) as the issuer
+
716  // - Issuing chain is IOU with non-door account (that does not
+
717  // exists on the issuing chain ledger) as the issuer
+
718  // - Issuing chain is XRP and issuing chain door account is not the
+
719  // root account
+
720  // - Issuing chain is XRP and issuing chain door account is the root
+
721  // account
+
722  // ---------------------------------------------------------------------
+
723  // That's 42 combinations. The only combinations that should succeed
+
724  // are:
+
725  // - Locking chain is any IOU,
+
726  // - Issuing chain is IOU with issuing chain door account as the
+
727  // issuer
+
728  // Locking chain is XRP,
+
729  // - Issuing chain is XRP with issuing chain is the root account.
+
730  // ---------------------------------------------------------------------
+
731  Account a, b;
+
732  Issue ia, ib;
+
733 
+
734  std::tuple lcs{
+
735  std::make_pair(
+
736  "Locking chain is IOU(locking chain door)",
+
737  [&](auto& env, bool) {
+
738  a = mcDoor;
+
739  ia = mcDoor["USD"];
+
740  }),
+
741  std::make_pair(
+
742  "Locking chain is IOU(issuing chain door funded on locking "
+
743  "chain)",
+
744  [&](auto& env, bool shouldFund) {
+
745  a = mcDoor;
+
746  ia = scDoor["USD"];
+
747  if (shouldFund)
+
748  env.fund(XRP(10000), scDoor);
+
749  }),
+
750  std::make_pair(
+
751  "Locking chain is IOU(issuing chain door account unfunded "
+
752  "on locking chain)",
753  [&](auto& env, bool) {
754  a = mcDoor;
-
755  ia = mcuGw["USD"];
+
755  ia = scDoor["USD"];
756  }),
-
757  std::make_pair("Locking chain is XRP", [&](auto& env, bool) {
-
758  a = mcDoor;
-
759  ia = xrpIssue();
-
760  })};
-
761 
-
762  std::tuple ics{
+
757  std::make_pair(
+
758  "Locking chain is IOU(bob funded on locking chain)",
+
759  [&](auto& env, bool) {
+
760  a = mcDoor;
+
761  ia = mcGw["USD"];
+
762  }),
763  std::make_pair(
-
764  "Issuing chain is IOU(issuing chain door account)",
+
764  "Locking chain is IOU(bob unfunded on locking chain)",
765  [&](auto& env, bool) {
-
766  b = scDoor;
-
767  ib = scDoor["USD"];
+
766  a = mcDoor;
+
767  ia = mcuGw["USD"];
768  }),
-
769  std::make_pair(
-
770  "Issuing chain is IOU(locking chain door funded on issuing "
-
771  "chain)",
-
772  [&](auto& env, bool shouldFund) {
-
773  b = scDoor;
-
774  ib = mcDoor["USD"];
-
775  if (shouldFund)
-
776  env.fund(XRP(10000), mcDoor);
-
777  }),
-
778  std::make_pair(
-
779  "Issuing chain is IOU(locking chain door unfunded on "
-
780  "issuing chain)",
-
781  [&](auto& env, bool) {
-
782  b = scDoor;
-
783  ib = mcDoor["USD"];
-
784  }),
-
785  std::make_pair(
-
786  "Issuing chain is IOU(bob funded on issuing chain)",
-
787  [&](auto& env, bool) {
-
788  b = scDoor;
-
789  ib = mcGw["USD"];
-
790  }),
-
791  std::make_pair(
-
792  "Issuing chain is IOU(bob unfunded on issuing chain)",
+
769  std::make_pair("Locking chain is XRP", [&](auto& env, bool) {
+
770  a = mcDoor;
+
771  ia = xrpIssue();
+
772  })};
+
773 
+
774  std::tuple ics{
+
775  std::make_pair(
+
776  "Issuing chain is IOU(issuing chain door account)",
+
777  [&](auto& env, bool) {
+
778  b = scDoor;
+
779  ib = scDoor["USD"];
+
780  }),
+
781  std::make_pair(
+
782  "Issuing chain is IOU(locking chain door funded on issuing "
+
783  "chain)",
+
784  [&](auto& env, bool shouldFund) {
+
785  b = scDoor;
+
786  ib = mcDoor["USD"];
+
787  if (shouldFund)
+
788  env.fund(XRP(10000), mcDoor);
+
789  }),
+
790  std::make_pair(
+
791  "Issuing chain is IOU(locking chain door unfunded on "
+
792  "issuing chain)",
793  [&](auto& env, bool) {
794  b = scDoor;
-
795  ib = mcuGw["USD"];
+
795  ib = mcDoor["USD"];
796  }),
797  std::make_pair(
-
798  "Issuing chain is XRP and issuing chain door account is "
-
799  "not the root account",
-
800  [&](auto& env, bool) {
-
801  b = scDoor;
-
802  ib = xrpIssue();
-
803  }),
-
804  std::make_pair(
-
805  "Issuing chain is XRP and issuing chain door account is "
-
806  "the root account ",
-
807  [&](auto& env, bool) {
-
808  b = Account::master;
-
809  ib = xrpIssue();
-
810  })};
-
811 
-
812  std::vector<std::pair<int, int>> expected_result{
-
813  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
814  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
815  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
816  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
817  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
818  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
819  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
820  {tesSUCCESS, tesSUCCESS},
-
821  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
822  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
823  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
824  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
798  "Issuing chain is IOU(bob funded on issuing chain)",
+
799  [&](auto& env, bool) {
+
800  b = scDoor;
+
801  ib = mcGw["USD"];
+
802  }),
+
803  std::make_pair(
+
804  "Issuing chain is IOU(bob unfunded on issuing chain)",
+
805  [&](auto& env, bool) {
+
806  b = scDoor;
+
807  ib = mcuGw["USD"];
+
808  }),
+
809  std::make_pair(
+
810  "Issuing chain is XRP and issuing chain door account is "
+
811  "not the root account",
+
812  [&](auto& env, bool) {
+
813  b = scDoor;
+
814  ib = xrpIssue();
+
815  }),
+
816  std::make_pair(
+
817  "Issuing chain is XRP and issuing chain door account is "
+
818  "the root account ",
+
819  [&](auto& env, bool) {
+
820  b = Account::master;
+
821  ib = xrpIssue();
+
822  })};
+
823 
+
824  std::vector<std::pair<int, int>> expected_result{
825  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
826  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
827  {tecNO_ISSUER, tesSUCCESS},
+
827  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
828  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
829  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
830  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
831  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
832  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
832  {tesSUCCESS, tesSUCCESS},
833  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
834  {tesSUCCESS, tesSUCCESS},
+
834  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
835  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
836  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
837  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
838  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
839  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
839  {tecNO_ISSUER, tesSUCCESS},
840  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
841  {tecNO_ISSUER, tesSUCCESS},
+
841  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
842  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
843  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
844  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
845  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
846  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
846  {tesSUCCESS, tesSUCCESS},
847  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
848  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
849  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
850  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
851  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
852  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
853  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
-
854  {tesSUCCESS, tesSUCCESS}};
-
855 
-
856  std::vector<std::tuple<TER, TER, bool>> test_result;
-
857 
-
858  auto testcase = [&](auto const& lc, auto const& ic) {
-
859  XEnv mcEnv(*this);
-
860  XEnv scEnv(*this, true);
-
861 
-
862  lc.second(mcEnv, true);
-
863  lc.second(scEnv, false);
-
864 
-
865  ic.second(mcEnv, false);
-
866  ic.second(scEnv, true);
+
853  {tecNO_ISSUER, tesSUCCESS},
+
854  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
855  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
856  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
857  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
858  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
859  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
860  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
861  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
862  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
863  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
864  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
865  {temXCHAIN_BRIDGE_BAD_ISSUES, temXCHAIN_BRIDGE_BAD_ISSUES},
+
866  {tesSUCCESS, tesSUCCESS}};
867 
-
868  auto const& expected = expected_result[test_result.size()];
+
868  std::vector<std::tuple<TER, TER, bool>> test_result;
869 
-
870  mcEnv.tx(
-
871  create_bridge(a, bridge(a, ia, b, ib)),
-
872  ter(TER::fromInt(expected.first)));
-
873  TER mcTER = mcEnv.env_.ter();
-
874 
-
875  scEnv.tx(
-
876  create_bridge(b, bridge(a, ia, b, ib)),
-
877  ter(TER::fromInt(expected.second)));
-
878  TER scTER = scEnv.env_.ter();
+
870  auto testcase = [&](auto const& lc, auto const& ic) {
+
871  XEnv mcEnv(*this);
+
872  XEnv scEnv(*this, true);
+
873 
+
874  lc.second(mcEnv, true);
+
875  lc.second(scEnv, false);
+
876 
+
877  ic.second(mcEnv, false);
+
878  ic.second(scEnv, true);
879 
-
880  bool pass = mcTER == tesSUCCESS && scTER == tesSUCCESS;
+
880  auto const& expected = expected_result[test_result.size()];
881 
-
882  test_result.emplace_back(mcTER, scTER, pass);
-
883  };
-
884 
-
885  auto apply_ics = [&](auto const& lc, auto const& ics) {
-
886  std::apply(
-
887  [&](auto const&... ic) { (testcase(lc, ic), ...); }, ics);
-
888  };
-
889 
-
890  std::apply([&](auto const&... lc) { (apply_ics(lc, ics), ...); }, lcs);
+
882  mcEnv.tx(
+
883  create_bridge(a, bridge(a, ia, b, ib)),
+
884  ter(TER::fromInt(expected.first)));
+
885  TER mcTER = mcEnv.env_.ter();
+
886 
+
887  scEnv.tx(
+
888  create_bridge(b, bridge(a, ia, b, ib)),
+
889  ter(TER::fromInt(expected.second)));
+
890  TER scTER = scEnv.env_.ter();
891 
-
892 #if GENERATE_MTX_OUTPUT
-
893  // optional output of matrix results in markdown format
-
894  // ----------------------------------------------------
-
895  std::string fname{std::tmpnam(nullptr)};
-
896  fname += ".md";
-
897  std::cout << "Markdown output for matrix test: " << fname << "\n";
-
898 
-
899  auto print_res = [](auto tup) -> std::string {
-
900  std::string status = std::string(transToken(std::get<0>(tup))) +
-
901  " / " + transToken(std::get<1>(tup));
-
902 
-
903  if (std::get<2>(tup))
-
904  return status;
-
905  else
-
906  {
-
907  // red
-
908  return std::string("`") + status + "`";
-
909  }
-
910  };
-
911 
-
912  auto output_table = [&](auto print_res) {
-
913  size_t test_idx = 0;
-
914  std::string res;
-
915  res.reserve(10000); // should be enough :-)
-
916 
-
917  // first two header lines
-
918  res += "| `issuing ->` | ";
-
919  std::apply(
-
920  [&](auto const&... ic) {
-
921  ((res += ic.first, res += " | "), ...);
-
922  },
-
923  ics);
-
924  res += "\n";
-
925 
-
926  res += "| :--- | ";
-
927  std::apply(
-
928  [&](auto const&... ic) {
-
929  (((void)ic.first, res += ":---: | "), ...);
-
930  },
-
931  ics);
-
932  res += "\n";
-
933 
-
934  auto output = [&](auto const& lc, auto const& ic) {
-
935  res += print_res(test_result[test_idx]);
-
936  res += " | ";
-
937  ++test_idx;
-
938  };
-
939 
-
940  auto output_ics = [&](auto const& lc, auto const& ics) {
-
941  res += "| ";
-
942  res += lc.first;
-
943  res += " | ";
-
944  std::apply(
-
945  [&](auto const&... ic) { (output(lc, ic), ...); }, ics);
-
946  res += "\n";
-
947  };
-
948 
-
949  std::apply(
-
950  [&](auto const&... lc) { (output_ics(lc, ics), ...); }, lcs);
+
892  bool pass = mcTER == tesSUCCESS && scTER == tesSUCCESS;
+
893 
+
894  test_result.emplace_back(mcTER, scTER, pass);
+
895  };
+
896 
+
897  auto apply_ics = [&](auto const& lc, auto const& ics) {
+
898  std::apply(
+
899  [&](auto const&... ic) { (testcase(lc, ic), ...); }, ics);
+
900  };
+
901 
+
902  std::apply([&](auto const&... lc) { (apply_ics(lc, ics), ...); }, lcs);
+
903 
+
904 #if GENERATE_MTX_OUTPUT
+
905  // optional output of matrix results in markdown format
+
906  // ----------------------------------------------------
+
907  std::string fname{std::tmpnam(nullptr)};
+
908  fname += ".md";
+
909  std::cout << "Markdown output for matrix test: " << fname << "\n";
+
910 
+
911  auto print_res = [](auto tup) -> std::string {
+
912  std::string status = std::string(transToken(std::get<0>(tup))) +
+
913  " / " + transToken(std::get<1>(tup));
+
914 
+
915  if (std::get<2>(tup))
+
916  return status;
+
917  else
+
918  {
+
919  // red
+
920  return std::string("`") + status + "`";
+
921  }
+
922  };
+
923 
+
924  auto output_table = [&](auto print_res) {
+
925  size_t test_idx = 0;
+
926  std::string res;
+
927  res.reserve(10000); // should be enough :-)
+
928 
+
929  // first two header lines
+
930  res += "| `issuing ->` | ";
+
931  std::apply(
+
932  [&](auto const&... ic) {
+
933  ((res += ic.first, res += " | "), ...);
+
934  },
+
935  ics);
+
936  res += "\n";
+
937 
+
938  res += "| :--- | ";
+
939  std::apply(
+
940  [&](auto const&... ic) {
+
941  (((void)ic.first, res += ":---: | "), ...);
+
942  },
+
943  ics);
+
944  res += "\n";
+
945 
+
946  auto output = [&](auto const& lc, auto const& ic) {
+
947  res += print_res(test_result[test_idx]);
+
948  res += " | ";
+
949  ++test_idx;
+
950  };
951 
-
952  return res;
-
953  };
-
954 
-
955  std::ofstream(fname) << output_table(print_res);
-
956 
-
957  std::string ter_fname{std::tmpnam(nullptr)};
-
958  std::cout << "ter output for matrix test: " << ter_fname << "\n";
-
959 
-
960  std::ofstream ofs(ter_fname);
-
961  for (auto& t : test_result)
-
962  {
-
963  ofs << "{ " << std::string(transToken(std::get<0>(t))) << ", "
-
964  << std::string(transToken(std::get<1>(t))) << "}\n,";
-
965  }
-
966 #endif
-
967  }
+
952  auto output_ics = [&](auto const& lc, auto const& ics) {
+
953  res += "| ";
+
954  res += lc.first;
+
955  res += " | ";
+
956  std::apply(
+
957  [&](auto const&... ic) { (output(lc, ic), ...); }, ics);
+
958  res += "\n";
+
959  };
+
960 
+
961  std::apply(
+
962  [&](auto const&... lc) { (output_ics(lc, ics), ...); }, lcs);
+
963 
+
964  return res;
+
965  };
+
966 
+
967  std::ofstream(fname) << output_table(print_res);
968 
-
969  void
-
970  testXChainModifyBridge()
-
971  {
-
972  using namespace jtx;
-
973  testcase("Modify Bridge");
-
974 
-
975  // Changing a non-existent bridge should fail
-
976  XEnv(*this).tx(
-
977  bridge_modify(
-
978  mcAlice,
-
979  bridge(mcAlice, mcGw["USD"], mcBob, mcBob["USD"]),
-
980  XRP(2),
-
981  std::nullopt),
-
982  ter(tecNO_ENTRY));
-
983 
-
984  // must change something
-
985  // XEnv(*this)
-
986  // .tx(create_bridge(mcDoor, jvb, XRP(1), XRP(1)))
-
987  // .tx(bridge_modify(mcDoor, jvb, XRP(1), XRP(1)),
-
988  // ter(temMALFORMED));
-
989 
-
990  // must change something
-
991  XEnv(*this)
-
992  .tx(create_bridge(mcDoor, jvb, XRP(1), XRP(1)))
-
993  .close()
-
994  .tx(bridge_modify(mcDoor, jvb, {}, {}), ter(temMALFORMED));
+
969  std::string ter_fname{std::tmpnam(nullptr)};
+
970  std::cout << "ter output for matrix test: " << ter_fname << "\n";
+
971 
+
972  std::ofstream ofs(ter_fname);
+
973  for (auto& t : test_result)
+
974  {
+
975  ofs << "{ " << std::string(transToken(std::get<0>(t))) << ", "
+
976  << std::string(transToken(std::get<1>(t))) << "}\n,";
+
977  }
+
978 #endif
+
979  }
+
980 
+
981  void
+
982  testXChainModifyBridge()
+
983  {
+
984  using namespace jtx;
+
985  testcase("Modify Bridge");
+
986 
+
987  // Changing a non-existent bridge should fail
+
988  XEnv(*this).tx(
+
989  bridge_modify(
+
990  mcAlice,
+
991  bridge(mcAlice, mcGw["USD"], mcBob, mcBob["USD"]),
+
992  XRP(2),
+
993  std::nullopt),
+
994  ter(tecNO_ENTRY));
995 
-
996  // Reward amount is non-xrp
-
997  XEnv(*this).tx(
-
998  bridge_modify(mcDoor, jvb, mcUSD(2), XRP(10)),
-
999  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
-
1000 
-
1001  // Reward amount is XRP and negative
-
1002  XEnv(*this).tx(
-
1003  bridge_modify(mcDoor, jvb, XRP(-2), XRP(10)),
-
1004  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
-
1005 
-
1006  // Min create amount is non-xrp
-
1007  XEnv(*this).tx(
-
1008  bridge_modify(mcDoor, jvb, XRP(2), mcUSD(10)),
-
1009  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
-
1010 
-
1011  // Min create amount is zero
-
1012  XEnv(*this).tx(
-
1013  bridge_modify(mcDoor, jvb, XRP(2), XRP(0)),
-
1014  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
-
1015 
-
1016  // Min create amount is negative
-
1017  XEnv(*this).tx(
-
1018  bridge_modify(mcDoor, jvb, XRP(2), XRP(-10)),
-
1019  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
-
1020 
-
1021  // First check the regular claim process (without bridge_modify)
-
1022  for (auto withClaim : {false, true})
-
1023  {
-
1024  XEnv mcEnv(*this);
-
1025  XEnv scEnv(*this, true);
-
1026 
-
1027  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1028 
-
1029  scEnv.tx(create_bridge(Account::master, jvb))
-
1030  .tx(jtx::signers(Account::master, quorum, signers))
-
1031  .close()
-
1032  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1033  .close();
-
1034 
-
1035  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1036  auto const amt = XRP(1000);
-
1037  std::uint32_t const claimID = 1;
-
1038  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1039 
-
1040  BalanceTransfer transfer(
-
1041  scEnv,
-
1042  Account::master,
-
1043  scBob,
-
1044  scAlice,
-
1045  &payees[0],
-
1046  UT_XCHAIN_DEFAULT_QUORUM,
-
1047  withClaim);
-
1048 
-
1049  scEnv
-
1050  .multiTx(claim_attestations(
-
1051  scAttester,
-
1052  jvb,
-
1053  mcAlice,
-
1054  amt,
-
1055  payees,
-
1056  true,
-
1057  claimID,
-
1058  dst,
-
1059  signers))
-
1060  .close();
-
1061 
-
1062  if (withClaim)
-
1063  {
-
1064  BEAST_EXPECT(transfer.has_not_happened());
-
1065 
-
1066  // need to submit a claim transactions
-
1067  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
1068  .close();
-
1069  }
-
1070 
-
1071  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
1072  }
+
996  // must change something
+
997  // XEnv(*this)
+
998  // .tx(create_bridge(mcDoor, jvb, XRP(1), XRP(1)))
+
999  // .tx(bridge_modify(mcDoor, jvb, XRP(1), XRP(1)),
+
1000  // ter(temMALFORMED));
+
1001 
+
1002  // must change something
+
1003  XEnv(*this)
+
1004  .tx(create_bridge(mcDoor, jvb, XRP(1), XRP(1)))
+
1005  .close()
+
1006  .tx(bridge_modify(mcDoor, jvb, {}, {}), ter(temMALFORMED));
+
1007 
+
1008  // Reward amount is non-xrp
+
1009  XEnv(*this).tx(
+
1010  bridge_modify(mcDoor, jvb, mcUSD(2), XRP(10)),
+
1011  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
+
1012 
+
1013  // Reward amount is XRP and negative
+
1014  XEnv(*this).tx(
+
1015  bridge_modify(mcDoor, jvb, XRP(-2), XRP(10)),
+
1016  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT));
+
1017 
+
1018  // Min create amount is non-xrp
+
1019  XEnv(*this).tx(
+
1020  bridge_modify(mcDoor, jvb, XRP(2), mcUSD(10)),
+
1021  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
+
1022 
+
1023  // Min create amount is zero
+
1024  XEnv(*this).tx(
+
1025  bridge_modify(mcDoor, jvb, XRP(2), XRP(0)),
+
1026  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
+
1027 
+
1028  // Min create amount is negative
+
1029  XEnv(*this).tx(
+
1030  bridge_modify(mcDoor, jvb, XRP(2), XRP(-10)),
+
1031  ter(temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT));
+
1032 
+
1033  // First check the regular claim process (without bridge_modify)
+
1034  for (auto withClaim : {false, true})
+
1035  {
+
1036  XEnv mcEnv(*this);
+
1037  XEnv scEnv(*this, true);
+
1038 
+
1039  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
1040 
+
1041  scEnv.tx(create_bridge(Account::master, jvb))
+
1042  .tx(jtx::signers(Account::master, quorum, signers))
+
1043  .close()
+
1044  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1045  .close();
+
1046 
+
1047  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1048  auto const amt = XRP(1000);
+
1049  std::uint32_t const claimID = 1;
+
1050  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1051 
+
1052  BalanceTransfer transfer(
+
1053  scEnv,
+
1054  Account::master,
+
1055  scBob,
+
1056  scAlice,
+
1057  &payees[0],
+
1058  UT_XCHAIN_DEFAULT_QUORUM,
+
1059  withClaim);
+
1060 
+
1061  scEnv
+
1062  .multiTx(claim_attestations(
+
1063  scAttester,
+
1064  jvb,
+
1065  mcAlice,
+
1066  amt,
+
1067  payees,
+
1068  true,
+
1069  claimID,
+
1070  dst,
+
1071  signers))
+
1072  .close();
1073 
-
1074  // Check that the reward paid from a claim Id was the reward when
-
1075  // the claim id was created, not the reward since the bridge was
-
1076  // modified.
-
1077  for (auto withClaim : {false, true})
-
1078  {
-
1079  XEnv mcEnv(*this);
-
1080  XEnv scEnv(*this, true);
-
1081 
-
1082  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1083 
-
1084  scEnv.tx(create_bridge(Account::master, jvb))
-
1085  .tx(jtx::signers(Account::master, quorum, signers))
-
1086  .close()
-
1087  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1088  .close();
-
1089 
-
1090  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1091  auto const amt = XRP(1000);
-
1092  std::uint32_t const claimID = 1;
-
1093  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1094 
-
1095  // Now modify the reward on the bridge
-
1096  mcEnv.tx(bridge_modify(mcDoor, jvb, XRP(2), XRP(10))).close();
-
1097  scEnv.tx(bridge_modify(Account::master, jvb, XRP(2), XRP(10)))
-
1098  .close();
-
1099 
-
1100  BalanceTransfer transfer(
-
1101  scEnv,
-
1102  Account::master,
-
1103  scBob,
-
1104  scAlice,
-
1105  &payees[0],
-
1106  UT_XCHAIN_DEFAULT_QUORUM,
-
1107  withClaim);
-
1108 
-
1109  scEnv
-
1110  .multiTx(claim_attestations(
-
1111  scAttester,
-
1112  jvb,
-
1113  mcAlice,
-
1114  amt,
-
1115  payees,
-
1116  true,
-
1117  claimID,
-
1118  dst,
-
1119  signers))
-
1120  .close();
-
1121 
-
1122  if (withClaim)
-
1123  {
-
1124  BEAST_EXPECT(transfer.has_not_happened());
-
1125 
-
1126  // need to submit a claim transactions
-
1127  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
1128  .close();
-
1129  }
-
1130 
-
1131  // make sure the reward accounts indeed received the original
-
1132  // split reward (1 split 5 ways) instead of the updated 2 XRP.
-
1133  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
1134  }
-
1135 
-
1136  // Check that the signatures used to verify attestations and decide
-
1137  // if there is a quorum are the current signer's list on the door
-
1138  // account, not the signer's list that was in effect when the claim
-
1139  // id was created.
-
1140  for (auto withClaim : {false, true})
-
1141  {
-
1142  XEnv mcEnv(*this);
-
1143  XEnv scEnv(*this, true);
-
1144 
-
1145  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1146 
-
1147  scEnv.tx(create_bridge(Account::master, jvb))
-
1148  .tx(jtx::signers(Account::master, quorum, signers))
-
1149  .close()
-
1150  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1151  .close();
-
1152 
-
1153  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1154  auto const amt = XRP(1000);
-
1155  std::uint32_t const claimID = 1;
-
1156  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1157 
-
1158  // change signers - claim should not be processed is the batch
-
1159  // is signed by original signers
-
1160  scEnv.tx(jtx::signers(Account::master, quorum, alt_signers))
-
1161  .close();
-
1162 
-
1163  BalanceTransfer transfer(
-
1164  scEnv,
-
1165  Account::master,
-
1166  scBob,
-
1167  scAlice,
-
1168  &payees[0],
-
1169  UT_XCHAIN_DEFAULT_QUORUM,
-
1170  withClaim);
-
1171 
-
1172  // submit claim using outdated signers - should fail
-
1173  scEnv
-
1174  .multiTx(
-
1175  claim_attestations(
-
1176  scAttester,
-
1177  jvb,
-
1178  mcAlice,
-
1179  amt,
-
1180  payees,
-
1181  true,
-
1182  claimID,
-
1183  dst,
-
1184  signers),
-
1185  ter(tecNO_PERMISSION))
-
1186  .close();
-
1187  if (withClaim)
-
1188  {
-
1189  // need to submit a claim transactions
-
1190  scEnv
-
1191  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
1192  ter(tecXCHAIN_CLAIM_NO_QUORUM))
-
1193  .close();
-
1194  }
-
1195 
-
1196  // make sure transfer has not happened as we sent attestations
-
1197  // using outdated signers
-
1198  BEAST_EXPECT(transfer.has_not_happened());
-
1199 
-
1200  // submit claim using current signers - should succeed
-
1201  scEnv
-
1202  .multiTx(claim_attestations(
-
1203  scAttester,
-
1204  jvb,
-
1205  mcAlice,
-
1206  amt,
-
1207  payees,
-
1208  true,
-
1209  claimID,
-
1210  dst,
-
1211  alt_signers))
-
1212  .close();
-
1213  if (withClaim)
-
1214  {
-
1215  BEAST_EXPECT(transfer.has_not_happened());
-
1216 
-
1217  // need to submit a claim transactions
-
1218  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
1219  .close();
-
1220  }
-
1221 
-
1222  // make sure the transfer went through as we sent attestations
-
1223  // using new signers
-
1224  BEAST_EXPECT(
-
1225  transfer.has_happened(amt, split_reward_quorum, false));
-
1226  }
-
1227 
-
1228  // coverage test: bridge_modify transaction with incorrect flag
-
1229  XEnv(*this)
-
1230  .tx(create_bridge(mcDoor, jvb))
-
1231  .close()
-
1232  .tx(bridge_modify(mcDoor, jvb, XRP(1), XRP(2)),
-
1233  txflags(tfFillOrKill),
-
1234  ter(temINVALID_FLAG));
-
1235 
-
1236  // coverage test: bridge_modify transaction with xchain feature
-
1237  // disabled
-
1238  XEnv(*this)
-
1239  .tx(create_bridge(mcDoor, jvb))
-
1240  .disableFeature(featureXChainBridge)
-
1241  .close()
-
1242  .tx(bridge_modify(mcDoor, jvb, XRP(1), XRP(2)), ter(temDISABLED));
-
1243 
-
1244  // coverage test: bridge_modify return temSIDECHAIN_NONDOOR_OWNER;
-
1245  XEnv(*this)
-
1246  .tx(create_bridge(mcDoor, jvb))
-
1247  .close()
-
1248  .tx(bridge_modify(mcAlice, jvb, XRP(1), XRP(2)),
-
1249  ter(temXCHAIN_BRIDGE_NONDOOR_OWNER));
-
1250 
+
1074  if (withClaim)
+
1075  {
+
1076  BEAST_EXPECT(transfer.has_not_happened());
+
1077 
+
1078  // need to submit a claim transactions
+
1079  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
1080  .close();
+
1081  }
+
1082 
+
1083  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
1084  }
+
1085 
+
1086  // Check that the reward paid from a claim Id was the reward when
+
1087  // the claim id was created, not the reward since the bridge was
+
1088  // modified.
+
1089  for (auto withClaim : {false, true})
+
1090  {
+
1091  XEnv mcEnv(*this);
+
1092  XEnv scEnv(*this, true);
+
1093 
+
1094  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
1095 
+
1096  scEnv.tx(create_bridge(Account::master, jvb))
+
1097  .tx(jtx::signers(Account::master, quorum, signers))
+
1098  .close()
+
1099  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1100  .close();
+
1101 
+
1102  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1103  auto const amt = XRP(1000);
+
1104  std::uint32_t const claimID = 1;
+
1105  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1106 
+
1107  // Now modify the reward on the bridge
+
1108  mcEnv.tx(bridge_modify(mcDoor, jvb, XRP(2), XRP(10))).close();
+
1109  scEnv.tx(bridge_modify(Account::master, jvb, XRP(2), XRP(10)))
+
1110  .close();
+
1111 
+
1112  BalanceTransfer transfer(
+
1113  scEnv,
+
1114  Account::master,
+
1115  scBob,
+
1116  scAlice,
+
1117  &payees[0],
+
1118  UT_XCHAIN_DEFAULT_QUORUM,
+
1119  withClaim);
+
1120 
+
1121  scEnv
+
1122  .multiTx(claim_attestations(
+
1123  scAttester,
+
1124  jvb,
+
1125  mcAlice,
+
1126  amt,
+
1127  payees,
+
1128  true,
+
1129  claimID,
+
1130  dst,
+
1131  signers))
+
1132  .close();
+
1133 
+
1134  if (withClaim)
+
1135  {
+
1136  BEAST_EXPECT(transfer.has_not_happened());
+
1137 
+
1138  // need to submit a claim transactions
+
1139  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
1140  .close();
+
1141  }
+
1142 
+
1143  // make sure the reward accounts indeed received the original
+
1144  // split reward (1 split 5 ways) instead of the updated 2 XRP.
+
1145  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
1146  }
+
1147 
+
1148  // Check that the signatures used to verify attestations and decide
+
1149  // if there is a quorum are the current signer's list on the door
+
1150  // account, not the signer's list that was in effect when the claim
+
1151  // id was created.
+
1152  for (auto withClaim : {false, true})
+
1153  {
+
1154  XEnv mcEnv(*this);
+
1155  XEnv scEnv(*this, true);
+
1156 
+
1157  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
1158 
+
1159  scEnv.tx(create_bridge(Account::master, jvb))
+
1160  .tx(jtx::signers(Account::master, quorum, signers))
+
1161  .close()
+
1162  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1163  .close();
+
1164 
+
1165  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1166  auto const amt = XRP(1000);
+
1167  std::uint32_t const claimID = 1;
+
1168  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1169 
+
1170  // change signers - claim should not be processed is the batch
+
1171  // is signed by original signers
+
1172  scEnv.tx(jtx::signers(Account::master, quorum, alt_signers))
+
1173  .close();
+
1174 
+
1175  BalanceTransfer transfer(
+
1176  scEnv,
+
1177  Account::master,
+
1178  scBob,
+
1179  scAlice,
+
1180  &payees[0],
+
1181  UT_XCHAIN_DEFAULT_QUORUM,
+
1182  withClaim);
+
1183 
+
1184  // submit claim using outdated signers - should fail
+
1185  scEnv
+
1186  .multiTx(
+
1187  claim_attestations(
+
1188  scAttester,
+
1189  jvb,
+
1190  mcAlice,
+
1191  amt,
+
1192  payees,
+
1193  true,
+
1194  claimID,
+
1195  dst,
+
1196  signers),
+
1197  ter(tecNO_PERMISSION))
+
1198  .close();
+
1199  if (withClaim)
+
1200  {
+
1201  // need to submit a claim transactions
+
1202  scEnv
+
1203  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
1204  ter(tecXCHAIN_CLAIM_NO_QUORUM))
+
1205  .close();
+
1206  }
+
1207 
+
1208  // make sure transfer has not happened as we sent attestations
+
1209  // using outdated signers
+
1210  BEAST_EXPECT(transfer.has_not_happened());
+
1211 
+
1212  // submit claim using current signers - should succeed
+
1213  scEnv
+
1214  .multiTx(claim_attestations(
+
1215  scAttester,
+
1216  jvb,
+
1217  mcAlice,
+
1218  amt,
+
1219  payees,
+
1220  true,
+
1221  claimID,
+
1222  dst,
+
1223  alt_signers))
+
1224  .close();
+
1225  if (withClaim)
+
1226  {
+
1227  BEAST_EXPECT(transfer.has_not_happened());
+
1228 
+
1229  // need to submit a claim transactions
+
1230  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
1231  .close();
+
1232  }
+
1233 
+
1234  // make sure the transfer went through as we sent attestations
+
1235  // using new signers
+
1236  BEAST_EXPECT(
+
1237  transfer.has_happened(amt, split_reward_quorum, false));
+
1238  }
+
1239 
+
1240  // coverage test: bridge_modify transaction with incorrect flag
+
1241  XEnv(*this)
+
1242  .tx(create_bridge(mcDoor, jvb))
+
1243  .close()
+
1244  .tx(bridge_modify(mcDoor, jvb, XRP(1), XRP(2)),
+
1245  txflags(tfFillOrKill),
+
1246  ter(temINVALID_FLAG));
+
1247 
+
1248  // coverage test: bridge_modify transaction with xchain feature
+
1249  // disabled
+
1250  XEnv(*this)
+
1251  .tx(create_bridge(mcDoor, jvb))
+
1252  .disableFeature(featureXChainBridge)
+
1253  .close()
+
1254  .tx(bridge_modify(mcDoor, jvb, XRP(1), XRP(2)), ter(temDISABLED));
+
1255 
+
1256  // coverage test: bridge_modify return temSIDECHAIN_NONDOOR_OWNER;
1257  XEnv(*this)
-
1258  .tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20)))
+
1258  .tx(create_bridge(mcDoor, jvb))
1259  .close()
-
1260  .tx(sidechain_xchain_account_create(
-
1261  mcAlice, jvb, scuAlice, XRP(100), reward))
-
1262  .close()
-
1263  .tx(bridge_modify(mcDoor, jvb, {}, XRP(2)),
-
1264  txflags(tfClearAccountCreateAmount),
-
1265  ter(temMALFORMED))
-
1266  .close()
-
1267  .tx(bridge_modify(mcDoor, jvb, XRP(3), {}),
-
1268  txflags(tfClearAccountCreateAmount))
-
1269  .close()
-
1270  .tx(sidechain_xchain_account_create(
-
1271  mcAlice, jvb, scuBob, XRP(100), XRP(3)),
-
1272  ter(tecXCHAIN_CREATE_ACCOUNT_DISABLED))
-
1273  .close();
-
1274  }
-
1275 
-
1276  void
-
1277  testXChainCreateClaimID()
-
1278  {
-
1279  using namespace jtx;
-
1280  XRPAmount res1 = reserve(1);
-
1281  XRPAmount tx_fee = txFee();
-
1282 
-
1283  testcase("Create ClaimID");
-
1284 
-
1285  // normal bridge create for sanity check with the exact necessary
-
1286  // account balance
-
1287  XEnv(*this, true)
-
1288  .tx(create_bridge(Account::master, jvb))
-
1289  .fund(res1, scuAlice) // acct reserve + 1 object
-
1290  .close()
-
1291  .tx(xchain_create_claim_id(scuAlice, jvb, reward, mcAlice))
-
1292  .close();
-
1293 
-
1294  // check reward not deducted when claim id is created
-
1295  {
-
1296  XEnv xenv(*this, true);
-
1297 
-
1298  Balance scAlice_bal(xenv, scAlice);
-
1299 
-
1300  xenv.tx(create_bridge(Account::master, jvb))
-
1301  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1302  .close();
-
1303 
-
1304  BEAST_EXPECT(scAlice_bal.diff() == -tx_fee);
-
1305  }
-
1306 
-
1307  // Non-existent bridge
-
1308  XEnv(*this, true)
-
1309  .tx(xchain_create_claim_id(
-
1310  scAlice,
-
1311  bridge(mcAlice, mcAlice["USD"], scBob, scBob["USD"]),
-
1312  reward,
-
1313  mcAlice),
-
1314  ter(tecNO_ENTRY))
-
1315  .close();
-
1316 
-
1317  // Creating the new object would put the account below the reserve
-
1318  XEnv(*this, true)
-
1319  .tx(create_bridge(Account::master, jvb))
-
1320  .fund(res1 - xrp_dust, scuAlice) // barely not enough
-
1321  .close()
-
1322  .tx(xchain_create_claim_id(scuAlice, jvb, reward, mcAlice),
-
1323  ter(tecINSUFFICIENT_RESERVE))
-
1324  .close();
-
1325 
-
1326  // The specified reward doesn't match the reward on the bridge (test
-
1327  // by giving the reward amount for the other side, as well as a
-
1328  // completely non-matching reward)
-
1329  XEnv(*this, true)
-
1330  .tx(create_bridge(Account::master, jvb))
-
1331  .close()
-
1332  .tx(xchain_create_claim_id(
-
1333  scAlice, jvb, split_reward_quorum, mcAlice),
-
1334  ter(tecXCHAIN_REWARD_MISMATCH))
-
1335  .close();
-
1336 
-
1337  // A reward amount that isn't XRP
-
1338  XEnv(*this, true)
-
1339  .tx(create_bridge(Account::master, jvb))
-
1340  .close()
-
1341  .tx(xchain_create_claim_id(scAlice, jvb, mcUSD(1), mcAlice),
-
1342  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT))
-
1343  .close();
-
1344 
-
1345  // coverage test: xchain_create_claim_id transaction with incorrect
-
1346  // flag
-
1347  XEnv(*this, true)
-
1348  .tx(create_bridge(Account::master, jvb))
-
1349  .close()
-
1350  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice),
-
1351  txflags(tfFillOrKill),
-
1352  ter(temINVALID_FLAG))
-
1353  .close();
-
1354 
-
1355  // coverage test: xchain_create_claim_id transaction with xchain
-
1356  // feature disabled
-
1357  XEnv(*this, true)
-
1358  .tx(create_bridge(Account::master, jvb))
-
1359  .disableFeature(featureXChainBridge)
-
1360  .close()
-
1361  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice),
-
1362  ter(temDISABLED))
-
1363  .close();
-
1364  }
-
1365 
-
1366  void
-
1367  testXChainCommit()
-
1368  {
-
1369  using namespace jtx;
-
1370  XRPAmount res0 = reserve(0);
-
1371  XRPAmount tx_fee = txFee();
-
1372 
-
1373  testcase("Commit");
-
1374 
-
1375  // Commit to a non-existent bridge
-
1376  XEnv(*this).tx(
-
1377  xchain_commit(mcAlice, jvb, 1, one_xrp, scBob), ter(tecNO_ENTRY));
-
1378 
-
1379  // check that reward not deducted when doing the commit
-
1380  {
-
1381  XEnv xenv(*this);
-
1382 
-
1383  Balance alice_bal(xenv, mcAlice);
-
1384  auto const amt = XRP(1000);
-
1385 
-
1386  xenv.tx(create_bridge(mcDoor, jvb))
-
1387  .close()
-
1388  .tx(xchain_commit(mcAlice, jvb, 1, amt, scBob))
-
1389  .close();
+
1260  .tx(bridge_modify(mcAlice, jvb, XRP(1), XRP(2)),
+
1261  ter(temXCHAIN_BRIDGE_NONDOOR_OWNER));
+
1262 
+
1269  XEnv(*this)
+
1270  .tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20)))
+
1271  .close()
+
1272  .tx(sidechain_xchain_account_create(
+
1273  mcAlice, jvb, scuAlice, XRP(100), reward))
+
1274  .close()
+
1275  .tx(bridge_modify(mcDoor, jvb, {}, XRP(2)),
+
1276  txflags(tfClearAccountCreateAmount),
+
1277  ter(temMALFORMED))
+
1278  .close()
+
1279  .tx(bridge_modify(mcDoor, jvb, XRP(3), {}),
+
1280  txflags(tfClearAccountCreateAmount))
+
1281  .close()
+
1282  .tx(sidechain_xchain_account_create(
+
1283  mcAlice, jvb, scuBob, XRP(100), XRP(3)),
+
1284  ter(tecXCHAIN_CREATE_ACCOUNT_DISABLED))
+
1285  .close();
+
1286  }
+
1287 
+
1288  void
+
1289  testXChainCreateClaimID()
+
1290  {
+
1291  using namespace jtx;
+
1292  XRPAmount res1 = reserve(1);
+
1293  XRPAmount tx_fee = txFee();
+
1294 
+
1295  testcase("Create ClaimID");
+
1296 
+
1297  // normal bridge create for sanity check with the exact necessary
+
1298  // account balance
+
1299  XEnv(*this, true)
+
1300  .tx(create_bridge(Account::master, jvb))
+
1301  .fund(res1, scuAlice) // acct reserve + 1 object
+
1302  .close()
+
1303  .tx(xchain_create_claim_id(scuAlice, jvb, reward, mcAlice))
+
1304  .close();
+
1305 
+
1306  // check reward not deducted when claim id is created
+
1307  {
+
1308  XEnv xenv(*this, true);
+
1309 
+
1310  Balance scAlice_bal(xenv, scAlice);
+
1311 
+
1312  xenv.tx(create_bridge(Account::master, jvb))
+
1313  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1314  .close();
+
1315 
+
1316  BEAST_EXPECT(scAlice_bal.diff() == -tx_fee);
+
1317  }
+
1318 
+
1319  // Non-existent bridge
+
1320  XEnv(*this, true)
+
1321  .tx(xchain_create_claim_id(
+
1322  scAlice,
+
1323  bridge(mcAlice, mcAlice["USD"], scBob, scBob["USD"]),
+
1324  reward,
+
1325  mcAlice),
+
1326  ter(tecNO_ENTRY))
+
1327  .close();
+
1328 
+
1329  // Creating the new object would put the account below the reserve
+
1330  XEnv(*this, true)
+
1331  .tx(create_bridge(Account::master, jvb))
+
1332  .fund(res1 - xrp_dust, scuAlice) // barely not enough
+
1333  .close()
+
1334  .tx(xchain_create_claim_id(scuAlice, jvb, reward, mcAlice),
+
1335  ter(tecINSUFFICIENT_RESERVE))
+
1336  .close();
+
1337 
+
1338  // The specified reward doesn't match the reward on the bridge (test
+
1339  // by giving the reward amount for the other side, as well as a
+
1340  // completely non-matching reward)
+
1341  XEnv(*this, true)
+
1342  .tx(create_bridge(Account::master, jvb))
+
1343  .close()
+
1344  .tx(xchain_create_claim_id(
+
1345  scAlice, jvb, split_reward_quorum, mcAlice),
+
1346  ter(tecXCHAIN_REWARD_MISMATCH))
+
1347  .close();
+
1348 
+
1349  // A reward amount that isn't XRP
+
1350  XEnv(*this, true)
+
1351  .tx(create_bridge(Account::master, jvb))
+
1352  .close()
+
1353  .tx(xchain_create_claim_id(scAlice, jvb, mcUSD(1), mcAlice),
+
1354  ter(temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT))
+
1355  .close();
+
1356 
+
1357  // coverage test: xchain_create_claim_id transaction with incorrect
+
1358  // flag
+
1359  XEnv(*this, true)
+
1360  .tx(create_bridge(Account::master, jvb))
+
1361  .close()
+
1362  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice),
+
1363  txflags(tfFillOrKill),
+
1364  ter(temINVALID_FLAG))
+
1365  .close();
+
1366 
+
1367  // coverage test: xchain_create_claim_id transaction with xchain
+
1368  // feature disabled
+
1369  XEnv(*this, true)
+
1370  .tx(create_bridge(Account::master, jvb))
+
1371  .disableFeature(featureXChainBridge)
+
1372  .close()
+
1373  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice),
+
1374  ter(temDISABLED))
+
1375  .close();
+
1376  }
+
1377 
+
1378  void
+
1379  testXChainCommit()
+
1380  {
+
1381  using namespace jtx;
+
1382  XRPAmount res0 = reserve(0);
+
1383  XRPAmount tx_fee = txFee();
+
1384 
+
1385  testcase("Commit");
+
1386 
+
1387  // Commit to a non-existent bridge
+
1388  XEnv(*this).tx(
+
1389  xchain_commit(mcAlice, jvb, 1, one_xrp, scBob), ter(tecNO_ENTRY));
1390 
-
1391  STAmount claim_cost = amt;
-
1392  BEAST_EXPECT(alice_bal.diff() == -(claim_cost + tx_fee));
-
1393  }
+
1391  // check that reward not deducted when doing the commit
+
1392  {
+
1393  XEnv xenv(*this);
1394 
-
1395  // Commit a negative amount
-
1396  XEnv(*this)
-
1397  .tx(create_bridge(mcDoor, jvb))
-
1398  .close()
-
1399  .tx(xchain_commit(mcAlice, jvb, 1, XRP(-1), scBob),
-
1400  ter(temBAD_AMOUNT));
-
1401 
-
1402  // Commit an amount whose issue that does not match the expected
-
1403  // issue on the bridge (either LockingChainIssue or
-
1404  // IssuingChainIssue, depending on the chain).
-
1405  XEnv(*this)
-
1406  .tx(create_bridge(mcDoor, jvb))
-
1407  .close()
-
1408  .tx(xchain_commit(mcAlice, jvb, 1, mcUSD(100), scBob),
-
1409  ter(temBAD_ISSUER));
-
1410 
-
1411  // Commit an amount that would put the sender below the required
-
1412  // reserve (if XRP)
-
1413  XEnv(*this)
-
1414  .tx(create_bridge(mcDoor, jvb))
-
1415  .fund(res0 + one_xrp - xrp_dust, mcuAlice) // barely not enough
-
1416  .close()
-
1417  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob),
-
1418  ter(tecUNFUNDED_PAYMENT));
-
1419 
-
1420  XEnv(*this)
-
1421  .tx(create_bridge(mcDoor, jvb))
-
1422  .fund(
-
1423  res0 + one_xrp + xrp_dust, // "xrp_dust" for tx fees
-
1424  mcuAlice) // exactly enough => should succeed
-
1425  .close()
-
1426  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob));
-
1427 
-
1428  // Commit an amount above the account's balance (for both XRP and
-
1429  // IOUs)
-
1430  XEnv(*this)
-
1431  .tx(create_bridge(mcDoor, jvb))
-
1432  .fund(res0, mcuAlice) // barely not enough
-
1433  .close()
-
1434  .tx(xchain_commit(mcuAlice, jvb, 1, res0 + one_xrp, scBob),
-
1435  ter(tecUNFUNDED_PAYMENT));
-
1436 
-
1437  auto jvb_USD = bridge(mcDoor, mcUSD, scGw, scUSD);
-
1438 
-
1439  // commit sent from iou issuer (mcGw) succeeds - should it?
-
1440  XEnv(*this)
-
1441  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
-
1442  .tx(create_bridge(mcDoor, jvb_USD))
-
1443  .close()
-
1444  .tx(xchain_commit(mcGw, jvb_USD, 1, mcUSD(1), scBob));
-
1445 
-
1446  // commit to a door account from the door account. This should fail.
-
1447  XEnv(*this)
-
1448  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
-
1449  .tx(create_bridge(mcDoor, jvb_USD))
-
1450  .close()
-
1451  .tx(xchain_commit(mcDoor, jvb_USD, 1, mcUSD(1), scBob),
-
1452  ter(tecXCHAIN_SELF_COMMIT));
-
1453 
-
1454  // commit sent from mcAlice which has no IOU balance => should fail
-
1455  XEnv(*this)
-
1456  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
-
1457  .tx(create_bridge(mcDoor, jvb_USD))
-
1458  .close()
-
1459  .tx(xchain_commit(mcAlice, jvb_USD, 1, mcUSD(1), scBob),
-
1460  ter(terNO_LINE));
-
1461 
-
1462  // commit sent from mcAlice which has no IOU balance => should fail
-
1463  // just changed the destination to scGw (which is the door account
-
1464  // and may not make much sense)
-
1465  XEnv(*this)
-
1466  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
-
1467  .tx(create_bridge(mcDoor, jvb_USD))
-
1468  .close()
-
1469  .tx(xchain_commit(mcAlice, jvb_USD, 1, mcUSD(1), scGw),
-
1470  ter(terNO_LINE));
-
1471 
-
1472  // commit sent from mcAlice which has a IOU balance => should
-
1473  // succeed
-
1474  XEnv(*this)
-
1475  .tx(trust(mcDoor, mcUSD(10000)))
-
1476  .tx(trust(mcAlice, mcUSD(10000)))
-
1477  .close()
-
1478  .tx(pay(mcGw, mcAlice, mcUSD(10)))
+
1395  Balance alice_bal(xenv, mcAlice);
+
1396  auto const amt = XRP(1000);
+
1397 
+
1398  xenv.tx(create_bridge(mcDoor, jvb))
+
1399  .close()
+
1400  .tx(xchain_commit(mcAlice, jvb, 1, amt, scBob))
+
1401  .close();
+
1402 
+
1403  STAmount claim_cost = amt;
+
1404  BEAST_EXPECT(alice_bal.diff() == -(claim_cost + tx_fee));
+
1405  }
+
1406 
+
1407  // Commit a negative amount
+
1408  XEnv(*this)
+
1409  .tx(create_bridge(mcDoor, jvb))
+
1410  .close()
+
1411  .tx(xchain_commit(mcAlice, jvb, 1, XRP(-1), scBob),
+
1412  ter(temBAD_AMOUNT));
+
1413 
+
1414  // Commit an amount whose issue that does not match the expected
+
1415  // issue on the bridge (either LockingChainIssue or
+
1416  // IssuingChainIssue, depending on the chain).
+
1417  XEnv(*this)
+
1418  .tx(create_bridge(mcDoor, jvb))
+
1419  .close()
+
1420  .tx(xchain_commit(mcAlice, jvb, 1, mcUSD(100), scBob),
+
1421  ter(temBAD_ISSUER));
+
1422 
+
1423  // Commit an amount that would put the sender below the required
+
1424  // reserve (if XRP)
+
1425  XEnv(*this)
+
1426  .tx(create_bridge(mcDoor, jvb))
+
1427  .fund(res0 + one_xrp - xrp_dust, mcuAlice) // barely not enough
+
1428  .close()
+
1429  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob),
+
1430  ter(tecUNFUNDED_PAYMENT));
+
1431 
+
1432  XEnv(*this)
+
1433  .tx(create_bridge(mcDoor, jvb))
+
1434  .fund(
+
1435  res0 + one_xrp + xrp_dust, // "xrp_dust" for tx fees
+
1436  mcuAlice) // exactly enough => should succeed
+
1437  .close()
+
1438  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob));
+
1439 
+
1440  // Commit an amount above the account's balance (for both XRP and
+
1441  // IOUs)
+
1442  XEnv(*this)
+
1443  .tx(create_bridge(mcDoor, jvb))
+
1444  .fund(res0, mcuAlice) // barely not enough
+
1445  .close()
+
1446  .tx(xchain_commit(mcuAlice, jvb, 1, res0 + one_xrp, scBob),
+
1447  ter(tecUNFUNDED_PAYMENT));
+
1448 
+
1449  auto jvb_USD = bridge(mcDoor, mcUSD, scGw, scUSD);
+
1450 
+
1451  // commit sent from iou issuer (mcGw) succeeds - should it?
+
1452  XEnv(*this)
+
1453  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
+
1454  .tx(create_bridge(mcDoor, jvb_USD))
+
1455  .close()
+
1456  .tx(xchain_commit(mcGw, jvb_USD, 1, mcUSD(1), scBob));
+
1457 
+
1458  // commit to a door account from the door account. This should fail.
+
1459  XEnv(*this)
+
1460  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
+
1461  .tx(create_bridge(mcDoor, jvb_USD))
+
1462  .close()
+
1463  .tx(xchain_commit(mcDoor, jvb_USD, 1, mcUSD(1), scBob),
+
1464  ter(tecXCHAIN_SELF_COMMIT));
+
1465 
+
1466  // commit sent from mcAlice which has no IOU balance => should fail
+
1467  XEnv(*this)
+
1468  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
+
1469  .tx(create_bridge(mcDoor, jvb_USD))
+
1470  .close()
+
1471  .tx(xchain_commit(mcAlice, jvb_USD, 1, mcUSD(1), scBob),
+
1472  ter(terNO_LINE));
+
1473 
+
1474  // commit sent from mcAlice which has no IOU balance => should fail
+
1475  // just changed the destination to scGw (which is the door account
+
1476  // and may not make much sense)
+
1477  XEnv(*this)
+
1478  .tx(trust(mcDoor, mcUSD(10000))) // door needs to have a trustline
1479  .tx(create_bridge(mcDoor, jvb_USD))
1480  .close()
-
1481  //.tx(pay(mcAlice, mcDoor, mcUSD(10)));
-
1482  .tx(xchain_commit(mcAlice, jvb_USD, 1, mcUSD(10), scAlice));
+
1481  .tx(xchain_commit(mcAlice, jvb_USD, 1, mcUSD(1), scGw),
+
1482  ter(terNO_LINE));
1483 
-
1484  // coverage test: xchain_commit transaction with incorrect flag
-
1485  XEnv(*this)
-
1486  .tx(create_bridge(mcDoor))
-
1487  .close()
-
1488  .tx(xchain_commit(mcAlice, jvb, 1, one_xrp, scBob),
-
1489  txflags(tfFillOrKill),
-
1490  ter(temINVALID_FLAG));
-
1491 
-
1492  // coverage test: xchain_commit transaction with xchain feature
-
1493  // disabled
-
1494  XEnv(*this)
-
1495  .tx(create_bridge(mcDoor))
-
1496  .disableFeature(featureXChainBridge)
-
1497  .close()
-
1498  .tx(xchain_commit(mcAlice, jvb, 1, one_xrp, scBob),
-
1499  ter(temDISABLED));
-
1500  }
-
1501 
-
1502  void
-
1503  testXChainAddAttestation()
-
1504  {
-
1505  using namespace jtx;
-
1506 
-
1507  testcase("Add Attestation");
-
1508  XRPAmount res0 = reserve(0);
-
1509  XRPAmount tx_fee = txFee();
-
1510 
-
1511  auto multiTtxFee = [&](std::uint32_t m) -> STAmount {
-
1512  return multiply(tx_fee, STAmount(m), xrpIssue());
-
1513  };
-
1514 
-
1515  // Add an attestation to a claim id that has already reached quorum.
-
1516  // This should succeed and share in the reward.
-
1517  // note: this is true only when either:
-
1518  // 1. dest account is not specified, so transfer requires a claim
-
1519  // 2. or the extra attestation is sent in the same batch as the
-
1520  // one reaching quorum
-
1521  for (auto withClaim : {true})
-
1522  {
-
1523  XEnv mcEnv(*this);
-
1524  XEnv scEnv(*this, true);
-
1525  std::uint32_t const claimID = 1;
+
1484  // commit sent from mcAlice which has a IOU balance => should
+
1485  // succeed
+
1486  XEnv(*this)
+
1487  .tx(trust(mcDoor, mcUSD(10000)))
+
1488  .tx(trust(mcAlice, mcUSD(10000)))
+
1489  .close()
+
1490  .tx(pay(mcGw, mcAlice, mcUSD(10)))
+
1491  .tx(create_bridge(mcDoor, jvb_USD))
+
1492  .close()
+
1493  //.tx(pay(mcAlice, mcDoor, mcUSD(10)));
+
1494  .tx(xchain_commit(mcAlice, jvb_USD, 1, mcUSD(10), scAlice));
+
1495 
+
1496  // coverage test: xchain_commit transaction with incorrect flag
+
1497  XEnv(*this)
+
1498  .tx(create_bridge(mcDoor))
+
1499  .close()
+
1500  .tx(xchain_commit(mcAlice, jvb, 1, one_xrp, scBob),
+
1501  txflags(tfFillOrKill),
+
1502  ter(temINVALID_FLAG));
+
1503 
+
1504  // coverage test: xchain_commit transaction with xchain feature
+
1505  // disabled
+
1506  XEnv(*this)
+
1507  .tx(create_bridge(mcDoor))
+
1508  .disableFeature(featureXChainBridge)
+
1509  .close()
+
1510  .tx(xchain_commit(mcAlice, jvb, 1, one_xrp, scBob),
+
1511  ter(temDISABLED));
+
1512  }
+
1513 
+
1514  void
+
1515  testXChainAddAttestation()
+
1516  {
+
1517  using namespace jtx;
+
1518 
+
1519  testcase("Add Attestation");
+
1520  XRPAmount res0 = reserve(0);
+
1521  XRPAmount tx_fee = txFee();
+
1522 
+
1523  auto multiTtxFee = [&](std::uint32_t m) -> STAmount {
+
1524  return multiply(tx_fee, STAmount(m), xrpIssue());
+
1525  };
1526 
-
1527  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1528 
-
1529  scEnv.tx(create_bridge(Account::master, jvb))
-
1530  .tx(jtx::signers(Account::master, quorum, signers))
-
1531  .close()
-
1532  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1533  .close();
-
1534 
-
1535  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
-
1536 
-
1537  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1538  auto const amt = XRP(1000);
-
1539  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1527  // Add an attestation to a claim id that has already reached quorum.
+
1528  // This should succeed and share in the reward.
+
1529  // note: this is true only when either:
+
1530  // 1. dest account is not specified, so transfer requires a claim
+
1531  // 2. or the extra attestation is sent in the same batch as the
+
1532  // one reaching quorum
+
1533  for (auto withClaim : {true})
+
1534  {
+
1535  XEnv mcEnv(*this);
+
1536  XEnv scEnv(*this, true);
+
1537  std::uint32_t const claimID = 1;
+
1538 
+
1539  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
1540 
-
1541  BalanceTransfer transfer(
-
1542  scEnv, Account::master, scBob, scAlice, payees, withClaim);
-
1543 
-
1544  scEnv
-
1545  .multiTx(claim_attestations(
-
1546  scAttester,
-
1547  jvb,
-
1548  mcAlice,
-
1549  amt,
-
1550  payees,
-
1551  true,
-
1552  claimID,
-
1553  dst,
-
1554  signers,
-
1555  UT_XCHAIN_DEFAULT_QUORUM))
-
1556  .close();
-
1557  scEnv
-
1558  .tx(claim_attestation(
-
1559  scAttester,
-
1560  jvb,
-
1561  mcAlice,
-
1562  amt,
-
1563  payees[UT_XCHAIN_DEFAULT_QUORUM],
-
1564  true,
-
1565  claimID,
-
1566  dst,
-
1567  signers[UT_XCHAIN_DEFAULT_QUORUM]))
+
1541  scEnv.tx(create_bridge(Account::master, jvb))
+
1542  .tx(jtx::signers(Account::master, quorum, signers))
+
1543  .close()
+
1544  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1545  .close();
+
1546 
+
1547  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
+
1548 
+
1549  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1550  auto const amt = XRP(1000);
+
1551  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1552 
+
1553  BalanceTransfer transfer(
+
1554  scEnv, Account::master, scBob, scAlice, payees, withClaim);
+
1555 
+
1556  scEnv
+
1557  .multiTx(claim_attestations(
+
1558  scAttester,
+
1559  jvb,
+
1560  mcAlice,
+
1561  amt,
+
1562  payees,
+
1563  true,
+
1564  claimID,
+
1565  dst,
+
1566  signers,
+
1567  UT_XCHAIN_DEFAULT_QUORUM))
1568  .close();
-
1569 
-
1570  if (withClaim)
-
1571  {
-
1572  BEAST_EXPECT(transfer.has_not_happened());
-
1573 
-
1574  // need to submit a claim transactions
-
1575  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
1576  .close();
-
1577  BEAST_EXPECT(!scEnv.claimID(jvb, claimID)); // claim id deleted
-
1578  BEAST_EXPECT(scEnv.claimID(jvb) == claimID);
-
1579  }
-
1580 
-
1581  BEAST_EXPECT(transfer.has_happened(amt, split_reward_everyone));
-
1582  }
-
1583 
-
1584  // Test that signature weights are correctly handled. Assign
-
1585  // signature weights of 1,2,4,4 and a quorum of 7. Check that the
-
1586  // 4,4 signatures reach a quorum, the 1,2,4, reach a quorum, but the
-
1587  // 4,2, 4,1 and 1,2 do not.
-
1588 
-
1589  // 1,2,4 => should succeed
-
1590  for (auto withClaim : {false, true})
-
1591  {
-
1592  XEnv mcEnv(*this);
-
1593  XEnv scEnv(*this, true);
-
1594 
-
1595  std::uint32_t const quorum_7 = 7;
-
1596  std::vector<signer> const signers_ = [] {
-
1597  constexpr int numSigners = 4;
-
1598  std::uint32_t weights[] = {1, 2, 4, 4};
-
1599 
-
1600  std::vector<signer> result;
-
1601  result.reserve(numSigners);
-
1602  for (int i = 0; i < numSigners; ++i)
-
1603  {
-
1604  using namespace std::literals;
-
1605  auto const a = Account("signer_"s + std::to_string(i));
-
1606  result.emplace_back(a, weights[i]);
-
1607  }
-
1608  return result;
-
1609  }();
-
1610 
-
1611  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1612 
-
1613  scEnv.tx(create_bridge(Account::master, jvb))
-
1614  .tx(jtx::signers(Account::master, quorum_7, signers_))
-
1615  .close()
-
1616  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1617  .close();
-
1618  std::uint32_t const claimID = 1;
-
1619  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
-
1620 
-
1621  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1622  auto const amt = XRP(1000);
-
1623 
-
1624  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1625 
-
1626  BalanceTransfer transfer(
-
1627  scEnv,
-
1628  Account::master,
-
1629  scBob,
-
1630  scAlice,
-
1631  &payees[0],
-
1632  3,
-
1633  withClaim);
-
1634 
-
1635  scEnv
-
1636  .multiTx(claim_attestations(
-
1637  scAttester,
-
1638  jvb,
-
1639  mcAlice,
-
1640  amt,
-
1641  payees,
-
1642  true,
-
1643  claimID,
-
1644  dst,
-
1645  signers_,
-
1646  3))
-
1647  .close();
-
1648 
-
1649  if (withClaim)
-
1650  {
-
1651  BEAST_EXPECT(transfer.has_not_happened());
-
1652 
-
1653  // need to submit a claim transactions
-
1654  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
1655  .close();
-
1656  }
-
1657 
-
1658  BEAST_EXPECT(!scEnv.claimID(jvb, 1)); // claim id deleted
-
1659 
-
1660  BEAST_EXPECT(transfer.has_happened(
-
1661  amt, divide(reward, STAmount(3), reward.issue())));
-
1662  }
-
1663 
-
1664  // 4,4 => should succeed
-
1665  for (auto withClaim : {false, true})
-
1666  {
-
1667  XEnv mcEnv(*this);
-
1668  XEnv scEnv(*this, true);
+
1569  scEnv
+
1570  .tx(claim_attestation(
+
1571  scAttester,
+
1572  jvb,
+
1573  mcAlice,
+
1574  amt,
+
1575  payees[UT_XCHAIN_DEFAULT_QUORUM],
+
1576  true,
+
1577  claimID,
+
1578  dst,
+
1579  signers[UT_XCHAIN_DEFAULT_QUORUM]))
+
1580  .close();
+
1581 
+
1582  if (withClaim)
+
1583  {
+
1584  BEAST_EXPECT(transfer.has_not_happened());
+
1585 
+
1586  // need to submit a claim transactions
+
1587  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
1588  .close();
+
1589  BEAST_EXPECT(!scEnv.claimID(jvb, claimID)); // claim id deleted
+
1590  BEAST_EXPECT(scEnv.claimID(jvb) == claimID);
+
1591  }
+
1592 
+
1593  BEAST_EXPECT(transfer.has_happened(amt, split_reward_everyone));
+
1594  }
+
1595 
+
1596  // Test that signature weights are correctly handled. Assign
+
1597  // signature weights of 1,2,4,4 and a quorum of 7. Check that the
+
1598  // 4,4 signatures reach a quorum, the 1,2,4, reach a quorum, but the
+
1599  // 4,2, 4,1 and 1,2 do not.
+
1600 
+
1601  // 1,2,4 => should succeed
+
1602  for (auto withClaim : {false, true})
+
1603  {
+
1604  XEnv mcEnv(*this);
+
1605  XEnv scEnv(*this, true);
+
1606 
+
1607  std::uint32_t const quorum_7 = 7;
+
1608  std::vector<signer> const signers_ = [] {
+
1609  constexpr int numSigners = 4;
+
1610  std::uint32_t weights[] = {1, 2, 4, 4};
+
1611 
+
1612  std::vector<signer> result;
+
1613  result.reserve(numSigners);
+
1614  for (int i = 0; i < numSigners; ++i)
+
1615  {
+
1616  using namespace std::literals;
+
1617  auto const a = Account("signer_"s + std::to_string(i));
+
1618  result.emplace_back(a, weights[i]);
+
1619  }
+
1620  return result;
+
1621  }();
+
1622 
+
1623  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
1624 
+
1625  scEnv.tx(create_bridge(Account::master, jvb))
+
1626  .tx(jtx::signers(Account::master, quorum_7, signers_))
+
1627  .close()
+
1628  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1629  .close();
+
1630  std::uint32_t const claimID = 1;
+
1631  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
+
1632 
+
1633  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1634  auto const amt = XRP(1000);
+
1635 
+
1636  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1637 
+
1638  BalanceTransfer transfer(
+
1639  scEnv,
+
1640  Account::master,
+
1641  scBob,
+
1642  scAlice,
+
1643  &payees[0],
+
1644  3,
+
1645  withClaim);
+
1646 
+
1647  scEnv
+
1648  .multiTx(claim_attestations(
+
1649  scAttester,
+
1650  jvb,
+
1651  mcAlice,
+
1652  amt,
+
1653  payees,
+
1654  true,
+
1655  claimID,
+
1656  dst,
+
1657  signers_,
+
1658  3))
+
1659  .close();
+
1660 
+
1661  if (withClaim)
+
1662  {
+
1663  BEAST_EXPECT(transfer.has_not_happened());
+
1664 
+
1665  // need to submit a claim transactions
+
1666  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
1667  .close();
+
1668  }
1669 
-
1670  std::uint32_t const quorum_7 = 7;
-
1671  std::vector<signer> const signers_ = [] {
-
1672  constexpr int numSigners = 4;
-
1673  std::uint32_t weights[] = {1, 2, 4, 4};
-
1674 
-
1675  std::vector<signer> result;
-
1676  result.reserve(numSigners);
-
1677  for (int i = 0; i < numSigners; ++i)
-
1678  {
-
1679  using namespace std::literals;
-
1680  auto const a = Account("signer_"s + std::to_string(i));
-
1681  result.emplace_back(a, weights[i]);
-
1682  }
-
1683  return result;
-
1684  }();
-
1685  STAmount const split_reward_ =
-
1686  divide(reward, STAmount(signers_.size()), reward.issue());
-
1687 
-
1688  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1689 
-
1690  scEnv.tx(create_bridge(Account::master, jvb))
-
1691  .tx(jtx::signers(Account::master, quorum_7, signers_))
-
1692  .close()
-
1693  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1694  .close();
-
1695  std::uint32_t const claimID = 1;
-
1696  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
-
1697 
-
1698  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1699  auto const amt = XRP(1000);
-
1700 
-
1701  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1702 
-
1703  BalanceTransfer transfer(
-
1704  scEnv,
-
1705  Account::master,
-
1706  scBob,
-
1707  scAlice,
-
1708  &payees[2],
-
1709  2,
-
1710  withClaim);
-
1711 
-
1712  scEnv
-
1713  .multiTx(claim_attestations(
-
1714  scAttester,
-
1715  jvb,
-
1716  mcAlice,
-
1717  amt,
-
1718  payees,
-
1719  true,
-
1720  claimID,
-
1721  dst,
-
1722  signers_,
-
1723  2,
-
1724  2))
-
1725  .close();
-
1726 
-
1727  if (withClaim)
-
1728  {
-
1729  BEAST_EXPECT(transfer.has_not_happened());
-
1730 
-
1731  // need to submit a claim transactions
-
1732  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
1733  .close();
-
1734  }
-
1735 
-
1736  BEAST_EXPECT(!scEnv.claimID(jvb, claimID)); // claim id deleted
-
1737 
-
1738  BEAST_EXPECT(transfer.has_happened(
-
1739  amt, divide(reward, STAmount(2), reward.issue())));
-
1740  }
-
1741 
-
1742  // 1,2 => should fail
-
1743  for (auto withClaim : {false, true})
-
1744  {
-
1745  XEnv mcEnv(*this);
-
1746  XEnv scEnv(*this, true);
+
1670  BEAST_EXPECT(!scEnv.claimID(jvb, 1)); // claim id deleted
+
1671 
+
1672  BEAST_EXPECT(transfer.has_happened(
+
1673  amt, divide(reward, STAmount(3), reward.issue())));
+
1674  }
+
1675 
+
1676  // 4,4 => should succeed
+
1677  for (auto withClaim : {false, true})
+
1678  {
+
1679  XEnv mcEnv(*this);
+
1680  XEnv scEnv(*this, true);
+
1681 
+
1682  std::uint32_t const quorum_7 = 7;
+
1683  std::vector<signer> const signers_ = [] {
+
1684  constexpr int numSigners = 4;
+
1685  std::uint32_t weights[] = {1, 2, 4, 4};
+
1686 
+
1687  std::vector<signer> result;
+
1688  result.reserve(numSigners);
+
1689  for (int i = 0; i < numSigners; ++i)
+
1690  {
+
1691  using namespace std::literals;
+
1692  auto const a = Account("signer_"s + std::to_string(i));
+
1693  result.emplace_back(a, weights[i]);
+
1694  }
+
1695  return result;
+
1696  }();
+
1697  STAmount const split_reward_ =
+
1698  divide(reward, STAmount(signers_.size()), reward.issue());
+
1699 
+
1700  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
1701 
+
1702  scEnv.tx(create_bridge(Account::master, jvb))
+
1703  .tx(jtx::signers(Account::master, quorum_7, signers_))
+
1704  .close()
+
1705  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1706  .close();
+
1707  std::uint32_t const claimID = 1;
+
1708  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
+
1709 
+
1710  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1711  auto const amt = XRP(1000);
+
1712 
+
1713  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1714 
+
1715  BalanceTransfer transfer(
+
1716  scEnv,
+
1717  Account::master,
+
1718  scBob,
+
1719  scAlice,
+
1720  &payees[2],
+
1721  2,
+
1722  withClaim);
+
1723 
+
1724  scEnv
+
1725  .multiTx(claim_attestations(
+
1726  scAttester,
+
1727  jvb,
+
1728  mcAlice,
+
1729  amt,
+
1730  payees,
+
1731  true,
+
1732  claimID,
+
1733  dst,
+
1734  signers_,
+
1735  2,
+
1736  2))
+
1737  .close();
+
1738 
+
1739  if (withClaim)
+
1740  {
+
1741  BEAST_EXPECT(transfer.has_not_happened());
+
1742 
+
1743  // need to submit a claim transactions
+
1744  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
1745  .close();
+
1746  }
1747 
-
1748  std::uint32_t const quorum_7 = 7;
-
1749  std::vector<signer> const signers_ = [] {
-
1750  constexpr int numSigners = 4;
-
1751  std::uint32_t weights[] = {1, 2, 4, 4};
-
1752 
-
1753  std::vector<signer> result;
-
1754  result.reserve(numSigners);
-
1755  for (int i = 0; i < numSigners; ++i)
-
1756  {
-
1757  using namespace std::literals;
-
1758  auto const a = Account("signer_"s + std::to_string(i));
-
1759  result.emplace_back(a, weights[i]);
-
1760  }
-
1761  return result;
-
1762  }();
-
1763 
-
1764  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1765 
-
1766  scEnv.tx(create_bridge(Account::master, jvb))
-
1767  .tx(jtx::signers(Account::master, quorum_7, signers_))
-
1768  .close()
-
1769  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1770  .close();
-
1771 
-
1772  std::uint32_t const claimID = 1;
-
1773  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
-
1774 
-
1775  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1776  auto const amt = XRP(1000);
-
1777  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1778 
-
1779  BalanceTransfer transfer(
-
1780  scEnv,
-
1781  Account::master,
-
1782  scBob,
-
1783  scAlice,
-
1784  &payees[0],
-
1785  2,
-
1786  withClaim);
-
1787 
-
1788  scEnv
-
1789  .multiTx(claim_attestations(
-
1790  scAttester,
-
1791  jvb,
-
1792  mcAlice,
-
1793  amt,
-
1794  payees,
-
1795  true,
-
1796  claimID,
-
1797  dst,
-
1798  signers_,
-
1799  2))
-
1800  .close();
-
1801  if (withClaim)
-
1802  {
-
1803  BEAST_EXPECT(transfer.has_not_happened());
-
1804 
-
1805  // need to submit a claim transactions
-
1806  scEnv
-
1807  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
1808  ter(tecXCHAIN_CLAIM_NO_QUORUM))
-
1809  .close();
-
1810  }
-
1811 
-
1812  BEAST_EXPECT(
-
1813  !!scEnv.claimID(jvb, claimID)); // claim id still present
-
1814  BEAST_EXPECT(transfer.has_not_happened());
-
1815  }
+
1748  BEAST_EXPECT(!scEnv.claimID(jvb, claimID)); // claim id deleted
+
1749 
+
1750  BEAST_EXPECT(transfer.has_happened(
+
1751  amt, divide(reward, STAmount(2), reward.issue())));
+
1752  }
+
1753 
+
1754  // 1,2 => should fail
+
1755  for (auto withClaim : {false, true})
+
1756  {
+
1757  XEnv mcEnv(*this);
+
1758  XEnv scEnv(*this, true);
+
1759 
+
1760  std::uint32_t const quorum_7 = 7;
+
1761  std::vector<signer> const signers_ = [] {
+
1762  constexpr int numSigners = 4;
+
1763  std::uint32_t weights[] = {1, 2, 4, 4};
+
1764 
+
1765  std::vector<signer> result;
+
1766  result.reserve(numSigners);
+
1767  for (int i = 0; i < numSigners; ++i)
+
1768  {
+
1769  using namespace std::literals;
+
1770  auto const a = Account("signer_"s + std::to_string(i));
+
1771  result.emplace_back(a, weights[i]);
+
1772  }
+
1773  return result;
+
1774  }();
+
1775 
+
1776  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
1777 
+
1778  scEnv.tx(create_bridge(Account::master, jvb))
+
1779  .tx(jtx::signers(Account::master, quorum_7, signers_))
+
1780  .close()
+
1781  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1782  .close();
+
1783 
+
1784  std::uint32_t const claimID = 1;
+
1785  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
+
1786 
+
1787  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1788  auto const amt = XRP(1000);
+
1789  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1790 
+
1791  BalanceTransfer transfer(
+
1792  scEnv,
+
1793  Account::master,
+
1794  scBob,
+
1795  scAlice,
+
1796  &payees[0],
+
1797  2,
+
1798  withClaim);
+
1799 
+
1800  scEnv
+
1801  .multiTx(claim_attestations(
+
1802  scAttester,
+
1803  jvb,
+
1804  mcAlice,
+
1805  amt,
+
1806  payees,
+
1807  true,
+
1808  claimID,
+
1809  dst,
+
1810  signers_,
+
1811  2))
+
1812  .close();
+
1813  if (withClaim)
+
1814  {
+
1815  BEAST_EXPECT(transfer.has_not_happened());
1816 
-
1817  // 2,4 => should fail
-
1818  for (auto withClaim : {false, true})
-
1819  {
-
1820  XEnv mcEnv(*this);
-
1821  XEnv scEnv(*this, true);
-
1822 
-
1823  std::uint32_t const quorum_7 = 7;
-
1824  std::vector<signer> const signers_ = [] {
-
1825  constexpr int numSigners = 4;
-
1826  std::uint32_t weights[] = {1, 2, 4, 4};
-
1827 
-
1828  std::vector<signer> result;
-
1829  result.reserve(numSigners);
-
1830  for (int i = 0; i < numSigners; ++i)
-
1831  {
-
1832  using namespace std::literals;
-
1833  auto const a = Account("signer_"s + std::to_string(i));
-
1834  result.emplace_back(a, weights[i]);
-
1835  }
-
1836  return result;
-
1837  }();
-
1838 
-
1839  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
1840 
-
1841  scEnv.tx(create_bridge(Account::master, jvb))
-
1842  .tx(jtx::signers(Account::master, quorum_7, signers_))
-
1843  .close()
-
1844  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
1845  .close();
-
1846 
-
1847  std::uint32_t const claimID = 1;
-
1848  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
-
1849 
-
1850  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
1851  auto const amt = XRP(1000);
+
1817  // need to submit a claim transactions
+
1818  scEnv
+
1819  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
1820  ter(tecXCHAIN_CLAIM_NO_QUORUM))
+
1821  .close();
+
1822  }
+
1823 
+
1824  BEAST_EXPECT(
+
1825  !!scEnv.claimID(jvb, claimID)); // claim id still present
+
1826  BEAST_EXPECT(transfer.has_not_happened());
+
1827  }
+
1828 
+
1829  // 2,4 => should fail
+
1830  for (auto withClaim : {false, true})
+
1831  {
+
1832  XEnv mcEnv(*this);
+
1833  XEnv scEnv(*this, true);
+
1834 
+
1835  std::uint32_t const quorum_7 = 7;
+
1836  std::vector<signer> const signers_ = [] {
+
1837  constexpr int numSigners = 4;
+
1838  std::uint32_t weights[] = {1, 2, 4, 4};
+
1839 
+
1840  std::vector<signer> result;
+
1841  result.reserve(numSigners);
+
1842  for (int i = 0; i < numSigners; ++i)
+
1843  {
+
1844  using namespace std::literals;
+
1845  auto const a = Account("signer_"s + std::to_string(i));
+
1846  result.emplace_back(a, weights[i]);
+
1847  }
+
1848  return result;
+
1849  }();
+
1850 
+
1851  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
1852 
-
1853  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
1854 
-
1855  BalanceTransfer transfer(
-
1856  scEnv,
-
1857  Account::master,
-
1858  scBob,
-
1859  scAlice,
-
1860  &payees[1],
-
1861  2,
-
1862  withClaim);
-
1863 
-
1864  scEnv
-
1865  .multiTx(claim_attestations(
-
1866  scAttester,
-
1867  jvb,
-
1868  mcAlice,
-
1869  amt,
-
1870  payees,
-
1871  true,
-
1872  claimID,
-
1873  dst,
-
1874  signers_,
-
1875  2,
-
1876  1))
-
1877  .close();
-
1878 
-
1879  if (withClaim)
-
1880  {
-
1881  BEAST_EXPECT(transfer.has_not_happened());
-
1882 
-
1883  // need to submit a claim transactions
-
1884  scEnv
-
1885  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
1886  ter(tecXCHAIN_CLAIM_NO_QUORUM))
-
1887  .close();
-
1888  }
-
1889 
-
1890  BEAST_EXPECT(
-
1891  !!scEnv.claimID(jvb, claimID)); // claim id still present
-
1892  BEAST_EXPECT(transfer.has_not_happened());
-
1893  }
+
1853  scEnv.tx(create_bridge(Account::master, jvb))
+
1854  .tx(jtx::signers(Account::master, quorum_7, signers_))
+
1855  .close()
+
1856  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
1857  .close();
+
1858 
+
1859  std::uint32_t const claimID = 1;
+
1860  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
+
1861 
+
1862  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
1863  auto const amt = XRP(1000);
+
1864 
+
1865  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
1866 
+
1867  BalanceTransfer transfer(
+
1868  scEnv,
+
1869  Account::master,
+
1870  scBob,
+
1871  scAlice,
+
1872  &payees[1],
+
1873  2,
+
1874  withClaim);
+
1875 
+
1876  scEnv
+
1877  .multiTx(claim_attestations(
+
1878  scAttester,
+
1879  jvb,
+
1880  mcAlice,
+
1881  amt,
+
1882  payees,
+
1883  true,
+
1884  claimID,
+
1885  dst,
+
1886  signers_,
+
1887  2,
+
1888  1))
+
1889  .close();
+
1890 
+
1891  if (withClaim)
+
1892  {
+
1893  BEAST_EXPECT(transfer.has_not_happened());
1894 
-
1895  // Confirm that account create transactions happen in the correct
-
1896  // order. If they reach quorum out of order they should not execute
-
1897  // until all the previous created transactions have occurred.
-
1898  // Re-adding an attestation should move funds.
-
1899  {
-
1900  XEnv mcEnv(*this);
-
1901  XEnv scEnv(*this, true);
-
1902  auto const amt = XRP(1000);
-
1903  auto const amt_plus_reward = amt + reward;
-
1904 
-
1905  {
-
1906  Balance door(mcEnv, mcDoor);
-
1907  Balance carol(mcEnv, mcCarol);
-
1908 
-
1909  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20)))
-
1910  .close()
-
1911  .tx(sidechain_xchain_account_create(
-
1912  mcAlice, jvb, scuAlice, amt, reward))
-
1913  .tx(sidechain_xchain_account_create(
-
1914  mcBob, jvb, scuBob, amt, reward))
-
1915  .tx(sidechain_xchain_account_create(
-
1916  mcCarol, jvb, scuCarol, amt, reward))
-
1917  .close();
-
1918 
-
1919  BEAST_EXPECT(
-
1920  door.diff() ==
-
1921  (multiply(amt_plus_reward, STAmount(3), xrpIssue()) -
-
1922  tx_fee));
-
1923  BEAST_EXPECT(carol.diff() == -(amt + reward + tx_fee));
-
1924  }
-
1925 
-
1926  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
-
1927  .tx(jtx::signers(Account::master, quorum, signers))
-
1928  .close();
-
1929 
-
1930  {
-
1931  // send first batch of account create attest for all 3
-
1932  // account create
-
1933  Balance attester(scEnv, scAttester);
-
1934  Balance door(scEnv, Account::master);
-
1935 
-
1936  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2))
-
1937  .multiTx(att_create_acct_vec(3, amt, scuCarol, 2))
-
1938  .multiTx(att_create_acct_vec(2, amt, scuBob, 2))
-
1939  .close();
-
1940 
-
1941  BEAST_EXPECT(door.diff() == STAmount(0));
-
1942  // att_create_acct_vec return vectors of size 2, so 2*3 txns
-
1943  BEAST_EXPECT(attester.diff() == -multiTtxFee(6));
-
1944 
-
1945  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // ca claim id present
-
1946  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // ca claim id present
-
1947  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // ca claim id present
-
1948  BEAST_EXPECT(
-
1949  scEnv.claimCount(jvb) == 0); // claim count still 0
-
1950  }
-
1951 
-
1952  {
-
1953  // complete attestations for 2nd account create => should
-
1954  // not complete
-
1955  Balance attester(scEnv, scAttester);
-
1956  Balance door(scEnv, Account::master);
-
1957 
-
1958  scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 3, 2))
-
1959  .close();
-
1960 
-
1961  BEAST_EXPECT(door.diff() == STAmount(0));
-
1962  // att_create_acct_vec return vectors of size 3, so 3 txns
-
1963  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
-
1964 
-
1965  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // ca claim id present
-
1966  BEAST_EXPECT(
-
1967  scEnv.claimCount(jvb) == 0); // claim count still 0
-
1968  }
+
1895  // need to submit a claim transactions
+
1896  scEnv
+
1897  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
1898  ter(tecXCHAIN_CLAIM_NO_QUORUM))
+
1899  .close();
+
1900  }
+
1901 
+
1902  BEAST_EXPECT(
+
1903  !!scEnv.claimID(jvb, claimID)); // claim id still present
+
1904  BEAST_EXPECT(transfer.has_not_happened());
+
1905  }
+
1906 
+
1907  // Confirm that account create transactions happen in the correct
+
1908  // order. If they reach quorum out of order they should not execute
+
1909  // until all the previous created transactions have occurred.
+
1910  // Re-adding an attestation should move funds.
+
1911  {
+
1912  XEnv mcEnv(*this);
+
1913  XEnv scEnv(*this, true);
+
1914  auto const amt = XRP(1000);
+
1915  auto const amt_plus_reward = amt + reward;
+
1916 
+
1917  {
+
1918  Balance door(mcEnv, mcDoor);
+
1919  Balance carol(mcEnv, mcCarol);
+
1920 
+
1921  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20)))
+
1922  .close()
+
1923  .tx(sidechain_xchain_account_create(
+
1924  mcAlice, jvb, scuAlice, amt, reward))
+
1925  .tx(sidechain_xchain_account_create(
+
1926  mcBob, jvb, scuBob, amt, reward))
+
1927  .tx(sidechain_xchain_account_create(
+
1928  mcCarol, jvb, scuCarol, amt, reward))
+
1929  .close();
+
1930 
+
1931  BEAST_EXPECT(
+
1932  door.diff() ==
+
1933  (multiply(amt_plus_reward, STAmount(3), xrpIssue()) -
+
1934  tx_fee));
+
1935  BEAST_EXPECT(carol.diff() == -(amt + reward + tx_fee));
+
1936  }
+
1937 
+
1938  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
+
1939  .tx(jtx::signers(Account::master, quorum, signers))
+
1940  .close();
+
1941 
+
1942  {
+
1943  // send first batch of account create attest for all 3
+
1944  // account create
+
1945  Balance attester(scEnv, scAttester);
+
1946  Balance door(scEnv, Account::master);
+
1947 
+
1948  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2))
+
1949  .multiTx(att_create_acct_vec(3, amt, scuCarol, 2))
+
1950  .multiTx(att_create_acct_vec(2, amt, scuBob, 2))
+
1951  .close();
+
1952 
+
1953  BEAST_EXPECT(door.diff() == STAmount(0));
+
1954  // att_create_acct_vec return vectors of size 2, so 2*3 txns
+
1955  BEAST_EXPECT(attester.diff() == -multiTtxFee(6));
+
1956 
+
1957  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // ca claim id present
+
1958  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // ca claim id present
+
1959  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // ca claim id present
+
1960  BEAST_EXPECT(
+
1961  scEnv.claimCount(jvb) == 0); // claim count still 0
+
1962  }
+
1963 
+
1964  {
+
1965  // complete attestations for 2nd account create => should
+
1966  // not complete
+
1967  Balance attester(scEnv, scAttester);
+
1968  Balance door(scEnv, Account::master);
1969 
-
1970  {
-
1971  // complete attestations for 3rd account create => should
-
1972  // not complete
-
1973  Balance attester(scEnv, scAttester);
-
1974  Balance door(scEnv, Account::master);
-
1975 
-
1976  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 3, 2))
-
1977  .close();
-
1978 
-
1979  BEAST_EXPECT(door.diff() == STAmount(0));
-
1980  // att_create_acct_vec return vectors of size 3, so 3 txns
-
1981  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
-
1982 
-
1983  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // ca claim id present
-
1984  BEAST_EXPECT(
-
1985  scEnv.claimCount(jvb) == 0); // claim count still 0
-
1986  }
+
1970  scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 3, 2))
+
1971  .close();
+
1972 
+
1973  BEAST_EXPECT(door.diff() == STAmount(0));
+
1974  // att_create_acct_vec return vectors of size 3, so 3 txns
+
1975  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
+
1976 
+
1977  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // ca claim id present
+
1978  BEAST_EXPECT(
+
1979  scEnv.claimCount(jvb) == 0); // claim count still 0
+
1980  }
+
1981 
+
1982  {
+
1983  // complete attestations for 3rd account create => should
+
1984  // not complete
+
1985  Balance attester(scEnv, scAttester);
+
1986  Balance door(scEnv, Account::master);
1987 
-
1988  {
-
1989  // complete attestations for 1st account create => account
-
1990  // should be created
-
1991  Balance attester(scEnv, scAttester);
-
1992  Balance door(scEnv, Account::master);
-
1993 
-
1994  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 3, 1))
-
1995  .close();
-
1996 
-
1997  BEAST_EXPECT(door.diff() == -amt_plus_reward);
-
1998  // att_create_acct_vec return vectors of size 3, so 3 txns
-
1999  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
-
2000  BEAST_EXPECT(scEnv.balance(scuAlice) == amt);
-
2001 
-
2002  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id 1 deleted
-
2003  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // claim id 2 present
-
2004  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // claim id 3 present
-
2005  BEAST_EXPECT(scEnv.claimCount(jvb) == 1); // claim count now 1
-
2006  }
-
2007 
-
2008  {
-
2009  // resend attestations for 3rd account create => still
-
2010  // should not complete
-
2011  Balance attester(scEnv, scAttester);
-
2012  Balance door(scEnv, Account::master);
+
1988  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 3, 2))
+
1989  .close();
+
1990 
+
1991  BEAST_EXPECT(door.diff() == STAmount(0));
+
1992  // att_create_acct_vec return vectors of size 3, so 3 txns
+
1993  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
+
1994 
+
1995  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // ca claim id present
+
1996  BEAST_EXPECT(
+
1997  scEnv.claimCount(jvb) == 0); // claim count still 0
+
1998  }
+
1999 
+
2000  {
+
2001  // complete attestations for 1st account create => account
+
2002  // should be created
+
2003  Balance attester(scEnv, scAttester);
+
2004  Balance door(scEnv, Account::master);
+
2005 
+
2006  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 3, 1))
+
2007  .close();
+
2008 
+
2009  BEAST_EXPECT(door.diff() == -amt_plus_reward);
+
2010  // att_create_acct_vec return vectors of size 3, so 3 txns
+
2011  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
+
2012  BEAST_EXPECT(scEnv.balance(scuAlice) == amt);
2013 
-
2014  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 3, 2))
-
2015  .close();
-
2016 
-
2017  BEAST_EXPECT(door.diff() == STAmount(0));
-
2018  // att_create_acct_vec return vectors of size 3, so 3 txns
-
2019  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
-
2020 
-
2021  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // claim id 2 present
-
2022  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // claim id 3 present
-
2023  BEAST_EXPECT(
-
2024  scEnv.claimCount(jvb) == 1); // claim count still 1
-
2025  }
-
2026 
-
2027  {
-
2028  // resend attestations for 2nd account create => account
-
2029  // should be created
-
2030  Balance attester(scEnv, scAttester);
-
2031  Balance door(scEnv, Account::master);
+
2014  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id 1 deleted
+
2015  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // claim id 2 present
+
2016  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // claim id 3 present
+
2017  BEAST_EXPECT(scEnv.claimCount(jvb) == 1); // claim count now 1
+
2018  }
+
2019 
+
2020  {
+
2021  // resend attestations for 3rd account create => still
+
2022  // should not complete
+
2023  Balance attester(scEnv, scAttester);
+
2024  Balance door(scEnv, Account::master);
+
2025 
+
2026  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 3, 2))
+
2027  .close();
+
2028 
+
2029  BEAST_EXPECT(door.diff() == STAmount(0));
+
2030  // att_create_acct_vec return vectors of size 3, so 3 txns
+
2031  BEAST_EXPECT(attester.diff() == -multiTtxFee(3));
2032 
-
2033  scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 1)).close();
-
2034 
-
2035  BEAST_EXPECT(door.diff() == -amt_plus_reward);
-
2036  BEAST_EXPECT(attester.diff() == -tx_fee);
-
2037  BEAST_EXPECT(scEnv.balance(scuBob) == amt);
+
2033  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 2)); // claim id 2 present
+
2034  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // claim id 3 present
+
2035  BEAST_EXPECT(
+
2036  scEnv.claimCount(jvb) == 1); // claim count still 1
+
2037  }
2038 
-
2039  BEAST_EXPECT(!scEnv.caClaimID(jvb, 2)); // claim id 2 deleted
-
2040  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // claim id 3 present
-
2041  BEAST_EXPECT(scEnv.claimCount(jvb) == 2); // claim count now 2
-
2042  }
-
2043  {
-
2044  // resend attestations for 3rc account create => account
-
2045  // should be created
-
2046  Balance attester(scEnv, scAttester);
-
2047  Balance door(scEnv, Account::master);
-
2048 
-
2049  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1)).close();
+
2039  {
+
2040  // resend attestations for 2nd account create => account
+
2041  // should be created
+
2042  Balance attester(scEnv, scAttester);
+
2043  Balance door(scEnv, Account::master);
+
2044 
+
2045  scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 1)).close();
+
2046 
+
2047  BEAST_EXPECT(door.diff() == -amt_plus_reward);
+
2048  BEAST_EXPECT(attester.diff() == -tx_fee);
+
2049  BEAST_EXPECT(scEnv.balance(scuBob) == amt);
2050 
-
2051  BEAST_EXPECT(door.diff() == -amt_plus_reward);
-
2052  BEAST_EXPECT(attester.diff() == -tx_fee);
-
2053  BEAST_EXPECT(scEnv.balance(scuCarol) == amt);
-
2054 
-
2055  BEAST_EXPECT(!scEnv.caClaimID(jvb, 3)); // claim id 3 deleted
-
2056  BEAST_EXPECT(scEnv.claimCount(jvb) == 3); // claim count now 3
-
2057  }
-
2058  }
-
2059 
-
2060  // Check that creating an account with less than the minimum reserve
-
2061  // fails.
-
2062  {
-
2063  XEnv mcEnv(*this);
-
2064  XEnv scEnv(*this, true);
-
2065 
-
2066  auto const amt = res0 - XRP(1);
-
2067  auto const amt_plus_reward = amt + reward;
-
2068 
-
2069  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
-
2070 
-
2071  {
-
2072  Balance door(mcEnv, mcDoor);
-
2073  Balance carol(mcEnv, mcCarol);
-
2074 
-
2075  mcEnv
-
2076  .tx(sidechain_xchain_account_create(
-
2077  mcCarol, jvb, scuAlice, amt, reward))
-
2078  .close();
-
2079 
-
2080  BEAST_EXPECT(door.diff() == amt_plus_reward);
-
2081  BEAST_EXPECT(carol.diff() == -(amt_plus_reward + tx_fee));
-
2082  }
-
2083 
-
2084  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
-
2085  .tx(jtx::signers(Account::master, quorum, signers))
-
2086  .close();
-
2087 
-
2088  Balance attester(scEnv, scAttester);
-
2089  Balance door(scEnv, Account::master);
-
2090 
-
2091  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2)).close();
-
2092  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
-
2093  BEAST_EXPECT(
-
2094  scEnv.claimCount(jvb) == 0); // claim count is one less
+
2051  BEAST_EXPECT(!scEnv.caClaimID(jvb, 2)); // claim id 2 deleted
+
2052  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 3)); // claim id 3 present
+
2053  BEAST_EXPECT(scEnv.claimCount(jvb) == 2); // claim count now 2
+
2054  }
+
2055  {
+
2056  // resend attestations for 3rc account create => account
+
2057  // should be created
+
2058  Balance attester(scEnv, scAttester);
+
2059  Balance door(scEnv, Account::master);
+
2060 
+
2061  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1)).close();
+
2062 
+
2063  BEAST_EXPECT(door.diff() == -amt_plus_reward);
+
2064  BEAST_EXPECT(attester.diff() == -tx_fee);
+
2065  BEAST_EXPECT(scEnv.balance(scuCarol) == amt);
+
2066 
+
2067  BEAST_EXPECT(!scEnv.caClaimID(jvb, 3)); // claim id 3 deleted
+
2068  BEAST_EXPECT(scEnv.claimCount(jvb) == 3); // claim count now 3
+
2069  }
+
2070  }
+
2071 
+
2072  // Check that creating an account with less than the minimum reserve
+
2073  // fails.
+
2074  {
+
2075  XEnv mcEnv(*this);
+
2076  XEnv scEnv(*this, true);
+
2077 
+
2078  auto const amt = res0 - XRP(1);
+
2079  auto const amt_plus_reward = amt + reward;
+
2080 
+
2081  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
+
2082 
+
2083  {
+
2084  Balance door(mcEnv, mcDoor);
+
2085  Balance carol(mcEnv, mcCarol);
+
2086 
+
2087  mcEnv
+
2088  .tx(sidechain_xchain_account_create(
+
2089  mcCarol, jvb, scuAlice, amt, reward))
+
2090  .close();
+
2091 
+
2092  BEAST_EXPECT(door.diff() == amt_plus_reward);
+
2093  BEAST_EXPECT(carol.diff() == -(amt_plus_reward + tx_fee));
+
2094  }
2095 
-
2096  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2, 2)).close();
-
2097  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
-
2098  BEAST_EXPECT(
-
2099  scEnv.claimCount(jvb) == 1); // claim count was incremented
-
2100 
-
2101  BEAST_EXPECT(attester.diff() == -multiTtxFee(4));
-
2102  BEAST_EXPECT(door.diff() == -reward);
-
2103  BEAST_EXPECT(!scEnv.account(scuAlice));
-
2104  }
-
2105 
-
2106  // Check that sending funds with an account create txn to an
-
2107  // existing account works.
-
2108  {
-
2109  XEnv mcEnv(*this);
-
2110  XEnv scEnv(*this, true);
-
2111 
-
2112  auto const amt = XRP(111);
-
2113  auto const amt_plus_reward = amt + reward;
-
2114 
-
2115  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
-
2116 
-
2117  {
-
2118  Balance door(mcEnv, mcDoor);
-
2119  Balance carol(mcEnv, mcCarol);
-
2120 
-
2121  mcEnv
-
2122  .tx(sidechain_xchain_account_create(
-
2123  mcCarol, jvb, scAlice, amt, reward))
-
2124  .close();
-
2125 
-
2126  BEAST_EXPECT(door.diff() == amt_plus_reward);
-
2127  BEAST_EXPECT(carol.diff() == -(amt_plus_reward + tx_fee));
-
2128  }
-
2129 
-
2130  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
-
2131  .tx(jtx::signers(Account::master, quorum, signers))
-
2132  .close();
-
2133 
-
2134  Balance attester(scEnv, scAttester);
-
2135  Balance door(scEnv, Account::master);
-
2136  Balance alice(scEnv, scAlice);
+
2096  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
+
2097  .tx(jtx::signers(Account::master, quorum, signers))
+
2098  .close();
+
2099 
+
2100  Balance attester(scEnv, scAttester);
+
2101  Balance door(scEnv, Account::master);
+
2102 
+
2103  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2)).close();
+
2104  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
+
2105  BEAST_EXPECT(
+
2106  scEnv.claimCount(jvb) == 0); // claim count is one less
+
2107 
+
2108  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2, 2)).close();
+
2109  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
+
2110  BEAST_EXPECT(
+
2111  scEnv.claimCount(jvb) == 1); // claim count was incremented
+
2112 
+
2113  BEAST_EXPECT(attester.diff() == -multiTtxFee(4));
+
2114  BEAST_EXPECT(door.diff() == -reward);
+
2115  BEAST_EXPECT(!scEnv.account(scuAlice));
+
2116  }
+
2117 
+
2118  // Check that sending funds with an account create txn to an
+
2119  // existing account works.
+
2120  {
+
2121  XEnv mcEnv(*this);
+
2122  XEnv scEnv(*this, true);
+
2123 
+
2124  auto const amt = XRP(111);
+
2125  auto const amt_plus_reward = amt + reward;
+
2126 
+
2127  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
+
2128 
+
2129  {
+
2130  Balance door(mcEnv, mcDoor);
+
2131  Balance carol(mcEnv, mcCarol);
+
2132 
+
2133  mcEnv
+
2134  .tx(sidechain_xchain_account_create(
+
2135  mcCarol, jvb, scAlice, amt, reward))
+
2136  .close();
2137 
-
2138  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2)).close();
-
2139  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
-
2140  BEAST_EXPECT(
-
2141  scEnv.claimCount(jvb) == 0); // claim count is one less
-
2142 
-
2143  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2, 2)).close();
-
2144  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
-
2145  BEAST_EXPECT(
-
2146  scEnv.claimCount(jvb) == 1); // claim count was incremented
-
2147 
-
2148  BEAST_EXPECT(door.diff() == -amt_plus_reward);
-
2149  BEAST_EXPECT(attester.diff() == -multiTtxFee(4));
-
2150  BEAST_EXPECT(alice.diff() == amt);
-
2151  }
-
2152 
-
2153  // Check that sending funds to an existing account with deposit auth
-
2154  // set fails for account create transactions.
-
2155  {
-
2156  XEnv mcEnv(*this);
-
2157  XEnv scEnv(*this, true);
-
2158 
-
2159  auto const amt = XRP(1000);
-
2160  auto const amt_plus_reward = amt + reward;
-
2161 
-
2162  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
-
2163 
-
2164  {
-
2165  Balance door(mcEnv, mcDoor);
-
2166  Balance carol(mcEnv, mcCarol);
-
2167 
-
2168  mcEnv
-
2169  .tx(sidechain_xchain_account_create(
-
2170  mcCarol, jvb, scAlice, amt, reward))
-
2171  .close();
-
2172 
-
2173  BEAST_EXPECT(door.diff() == amt_plus_reward);
-
2174  BEAST_EXPECT(carol.diff() == -(amt_plus_reward + tx_fee));
-
2175  }
-
2176 
-
2177  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
-
2178  .tx(jtx::signers(Account::master, quorum, signers))
-
2179  .tx(fset("scAlice", asfDepositAuth)) // set deposit auth
-
2180  .close();
-
2181 
-
2182  Balance attester(scEnv, scAttester);
-
2183  Balance door(scEnv, Account::master);
-
2184  Balance alice(scEnv, scAlice);
-
2185 
-
2186  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2)).close();
-
2187  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
-
2188  BEAST_EXPECT(
-
2189  scEnv.claimCount(jvb) == 0); // claim count is one less
-
2190 
-
2191  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2, 2)).close();
-
2192  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
-
2193  BEAST_EXPECT(
-
2194  scEnv.claimCount(jvb) == 1); // claim count was incremented
-
2195 
-
2196  BEAST_EXPECT(door.diff() == -reward);
-
2197  BEAST_EXPECT(attester.diff() == -multiTtxFee(4));
-
2198  BEAST_EXPECT(alice.diff() == STAmount(0));
-
2199  }
-
2200 
-
2201  // If an account is unable to pay the reserve, check that it fails.
-
2202  // [greg todo] I don't know what this should test??
-
2203 
-
2204  // If an attestation already exists for that server and claim id,
-
2205  // the new attestation should replace the old attestation
-
2206  {
-
2207  XEnv mcEnv(*this);
-
2208  XEnv scEnv(*this, true);
-
2209  auto const amt = XRP(1000);
-
2210  auto const amt_plus_reward = amt + reward;
-
2211 
-
2212  {
-
2213  Balance door(mcEnv, mcDoor);
-
2214  Balance carol(mcEnv, mcCarol);
+
2138  BEAST_EXPECT(door.diff() == amt_plus_reward);
+
2139  BEAST_EXPECT(carol.diff() == -(amt_plus_reward + tx_fee));
+
2140  }
+
2141 
+
2142  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
+
2143  .tx(jtx::signers(Account::master, quorum, signers))
+
2144  .close();
+
2145 
+
2146  Balance attester(scEnv, scAttester);
+
2147  Balance door(scEnv, Account::master);
+
2148  Balance alice(scEnv, scAlice);
+
2149 
+
2150  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2)).close();
+
2151  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
+
2152  BEAST_EXPECT(
+
2153  scEnv.claimCount(jvb) == 0); // claim count is one less
+
2154 
+
2155  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2, 2)).close();
+
2156  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
+
2157  BEAST_EXPECT(
+
2158  scEnv.claimCount(jvb) == 1); // claim count was incremented
+
2159 
+
2160  BEAST_EXPECT(door.diff() == -amt_plus_reward);
+
2161  BEAST_EXPECT(attester.diff() == -multiTtxFee(4));
+
2162  BEAST_EXPECT(alice.diff() == amt);
+
2163  }
+
2164 
+
2165  // Check that sending funds to an existing account with deposit auth
+
2166  // set fails for account create transactions.
+
2167  {
+
2168  XEnv mcEnv(*this);
+
2169  XEnv scEnv(*this, true);
+
2170 
+
2171  auto const amt = XRP(1000);
+
2172  auto const amt_plus_reward = amt + reward;
+
2173 
+
2174  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
+
2175 
+
2176  {
+
2177  Balance door(mcEnv, mcDoor);
+
2178  Balance carol(mcEnv, mcCarol);
+
2179 
+
2180  mcEnv
+
2181  .tx(sidechain_xchain_account_create(
+
2182  mcCarol, jvb, scAlice, amt, reward))
+
2183  .close();
+
2184 
+
2185  BEAST_EXPECT(door.diff() == amt_plus_reward);
+
2186  BEAST_EXPECT(carol.diff() == -(amt_plus_reward + tx_fee));
+
2187  }
+
2188 
+
2189  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
+
2190  .tx(jtx::signers(Account::master, quorum, signers))
+
2191  .tx(fset("scAlice", asfDepositAuth)) // set deposit auth
+
2192  .close();
+
2193 
+
2194  Balance attester(scEnv, scAttester);
+
2195  Balance door(scEnv, Account::master);
+
2196  Balance alice(scEnv, scAlice);
+
2197 
+
2198  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2)).close();
+
2199  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
+
2200  BEAST_EXPECT(
+
2201  scEnv.claimCount(jvb) == 0); // claim count is one less
+
2202 
+
2203  scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2, 2)).close();
+
2204  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
+
2205  BEAST_EXPECT(
+
2206  scEnv.claimCount(jvb) == 1); // claim count was incremented
+
2207 
+
2208  BEAST_EXPECT(door.diff() == -reward);
+
2209  BEAST_EXPECT(attester.diff() == -multiTtxFee(4));
+
2210  BEAST_EXPECT(alice.diff() == STAmount(0));
+
2211  }
+
2212 
+
2213  // If an account is unable to pay the reserve, check that it fails.
+
2214  // [greg todo] I don't know what this should test??
2215 
-
2216  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20)))
-
2217  .close()
-
2218  .tx(sidechain_xchain_account_create(
-
2219  mcAlice, jvb, scuAlice, amt, reward))
-
2220  .close() // make sure Alice gets claim #1
-
2221  .tx(sidechain_xchain_account_create(
-
2222  mcBob, jvb, scuBob, amt, reward))
-
2223  .close() // make sure Bob gets claim #2
-
2224  .tx(sidechain_xchain_account_create(
-
2225  mcCarol, jvb, scuCarol, amt, reward))
-
2226  .close(); // and Carol will get claim #3
+
2216  // If an attestation already exists for that server and claim id,
+
2217  // the new attestation should replace the old attestation
+
2218  {
+
2219  XEnv mcEnv(*this);
+
2220  XEnv scEnv(*this, true);
+
2221  auto const amt = XRP(1000);
+
2222  auto const amt_plus_reward = amt + reward;
+
2223 
+
2224  {
+
2225  Balance door(mcEnv, mcDoor);
+
2226  Balance carol(mcEnv, mcCarol);
2227 
-
2228  BEAST_EXPECT(
-
2229  door.diff() ==
-
2230  (multiply(amt_plus_reward, STAmount(3), xrpIssue()) -
-
2231  tx_fee));
-
2232  BEAST_EXPECT(carol.diff() == -(amt + reward + tx_fee));
-
2233  }
-
2234 
-
2235  std::uint32_t const red_quorum = 2;
-
2236  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
-
2237  .tx(jtx::signers(Account::master, red_quorum, signers))
-
2238  .close();
+
2228  mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20)))
+
2229  .close()
+
2230  .tx(sidechain_xchain_account_create(
+
2231  mcAlice, jvb, scuAlice, amt, reward))
+
2232  .close() // make sure Alice gets claim #1
+
2233  .tx(sidechain_xchain_account_create(
+
2234  mcBob, jvb, scuBob, amt, reward))
+
2235  .close() // make sure Bob gets claim #2
+
2236  .tx(sidechain_xchain_account_create(
+
2237  mcCarol, jvb, scuCarol, amt, reward))
+
2238  .close(); // and Carol will get claim #3
2239 
-
2240  {
-
2241  Balance attester(scEnv, scAttester);
-
2242  Balance door(scEnv, Account::master);
-
2243  auto const bad_amt = XRP(10);
-
2244  std::uint32_t txCount = 0;
-
2245 
-
2246  // send attestations with incorrect amounts to for all 3
-
2247  // AccountCreate. They will be replaced later
-
2248  scEnv.multiTx(att_create_acct_vec(1, bad_amt, scuAlice, 1))
-
2249  .multiTx(att_create_acct_vec(2, bad_amt, scuBob, 1, 2))
-
2250  .multiTx(att_create_acct_vec(3, bad_amt, scuCarol, 1, 1))
-
2251  .close();
-
2252  txCount += 3;
-
2253 
-
2254  BEAST_EXPECTS(!!scEnv.caClaimID(jvb, 1), "claim id 1 created");
-
2255  BEAST_EXPECTS(!!scEnv.caClaimID(jvb, 2), "claim id 2 created");
-
2256  BEAST_EXPECTS(!!scEnv.caClaimID(jvb, 3), "claim id 3 created");
+
2240  BEAST_EXPECT(
+
2241  door.diff() ==
+
2242  (multiply(amt_plus_reward, STAmount(3), xrpIssue()) -
+
2243  tx_fee));
+
2244  BEAST_EXPECT(carol.diff() == -(amt + reward + tx_fee));
+
2245  }
+
2246 
+
2247  std::uint32_t const red_quorum = 2;
+
2248  scEnv.tx(create_bridge(Account::master, jvb, reward, XRP(20)))
+
2249  .tx(jtx::signers(Account::master, red_quorum, signers))
+
2250  .close();
+
2251 
+
2252  {
+
2253  Balance attester(scEnv, scAttester);
+
2254  Balance door(scEnv, Account::master);
+
2255  auto const bad_amt = XRP(10);
+
2256  std::uint32_t txCount = 0;
2257 
-
2258  // note: if we send inconsistent attestations in the same
-
2259  // batch, the transaction errors.
-
2260 
-
2261  // from now on we send correct attestations
-
2262  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 1, 0))
-
2263  .multiTx(att_create_acct_vec(2, amt, scuBob, 1, 2))
-
2264  .multiTx(att_create_acct_vec(3, amt, scuCarol, 1, 4))
-
2265  .close();
-
2266  txCount += 3;
-
2267 
-
2268  BEAST_EXPECTS(
-
2269  !!scEnv.caClaimID(jvb, 1), "claim id 1 still there");
-
2270  BEAST_EXPECTS(
-
2271  !!scEnv.caClaimID(jvb, 2), "claim id 2 still there");
-
2272  BEAST_EXPECTS(
-
2273  !!scEnv.caClaimID(jvb, 3), "claim id 3 still there");
-
2274  BEAST_EXPECTS(
-
2275  scEnv.claimCount(jvb) == 0, "No account created yet");
-
2276 
-
2277  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1, 1))
-
2278  .close();
-
2279  txCount += 1;
-
2280 
-
2281  BEAST_EXPECTS(
-
2282  !!scEnv.caClaimID(jvb, 3), "claim id 3 still there");
-
2283  BEAST_EXPECTS(
-
2284  scEnv.claimCount(jvb) == 0, "No account created yet");
-
2285 
-
2286  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 1, 2))
-
2287  .close();
-
2288  txCount += 1;
-
2289 
-
2290  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 1), "claim id 1 deleted");
-
2291  BEAST_EXPECTS(scEnv.claimCount(jvb) == 1, "scuAlice created");
+
2258  // send attestations with incorrect amounts to for all 3
+
2259  // AccountCreate. They will be replaced later
+
2260  scEnv.multiTx(att_create_acct_vec(1, bad_amt, scuAlice, 1))
+
2261  .multiTx(att_create_acct_vec(2, bad_amt, scuBob, 1, 2))
+
2262  .multiTx(att_create_acct_vec(3, bad_amt, scuCarol, 1, 1))
+
2263  .close();
+
2264  txCount += 3;
+
2265 
+
2266  BEAST_EXPECTS(!!scEnv.caClaimID(jvb, 1), "claim id 1 created");
+
2267  BEAST_EXPECTS(!!scEnv.caClaimID(jvb, 2), "claim id 2 created");
+
2268  BEAST_EXPECTS(!!scEnv.caClaimID(jvb, 3), "claim id 3 created");
+
2269 
+
2270  // note: if we send inconsistent attestations in the same
+
2271  // batch, the transaction errors.
+
2272 
+
2273  // from now on we send correct attestations
+
2274  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 1, 0))
+
2275  .multiTx(att_create_acct_vec(2, amt, scuBob, 1, 2))
+
2276  .multiTx(att_create_acct_vec(3, amt, scuCarol, 1, 4))
+
2277  .close();
+
2278  txCount += 3;
+
2279 
+
2280  BEAST_EXPECTS(
+
2281  !!scEnv.caClaimID(jvb, 1), "claim id 1 still there");
+
2282  BEAST_EXPECTS(
+
2283  !!scEnv.caClaimID(jvb, 2), "claim id 2 still there");
+
2284  BEAST_EXPECTS(
+
2285  !!scEnv.caClaimID(jvb, 3), "claim id 3 still there");
+
2286  BEAST_EXPECTS(
+
2287  scEnv.claimCount(jvb) == 0, "No account created yet");
+
2288 
+
2289  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1, 1))
+
2290  .close();
+
2291  txCount += 1;
2292 
-
2293  scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 1, 3))
-
2294  .multiTx(
-
2295  att_create_acct_vec(1, amt, scuAlice, 1, 3),
-
2296  ter(tecXCHAIN_ACCOUNT_CREATE_PAST))
-
2297  .close();
-
2298  txCount += 2;
-
2299 
-
2300  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 2), "claim id 2 deleted");
-
2301  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 1), "claim id 1 not added");
-
2302  BEAST_EXPECTS(
-
2303  scEnv.claimCount(jvb) == 2, "scuAlice & scuBob created");
+
2293  BEAST_EXPECTS(
+
2294  !!scEnv.caClaimID(jvb, 3), "claim id 3 still there");
+
2295  BEAST_EXPECTS(
+
2296  scEnv.claimCount(jvb) == 0, "No account created yet");
+
2297 
+
2298  scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 1, 2))
+
2299  .close();
+
2300  txCount += 1;
+
2301 
+
2302  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 1), "claim id 1 deleted");
+
2303  BEAST_EXPECTS(scEnv.claimCount(jvb) == 1, "scuAlice created");
2304 
-
2305  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1, 0))
-
2306  .close();
-
2307  txCount += 1;
-
2308 
-
2309  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 3), "claim id 3 deleted");
-
2310  BEAST_EXPECTS(
-
2311  scEnv.claimCount(jvb) == 3, "All 3 accounts created");
-
2312 
-
2313  // because of the division of the rewards among attesters,
-
2314  // sometimes a couple drops are left over unspent in the
-
2315  // door account (here 2 drops)
-
2316  BEAST_EXPECT(
-
2317  multiply(amt_plus_reward, STAmount(3), xrpIssue()) +
-
2318  door.diff() <
-
2319  drops(3));
-
2320  BEAST_EXPECT(attester.diff() == -multiTtxFee(txCount));
-
2321  BEAST_EXPECT(scEnv.balance(scuAlice) == amt);
-
2322  BEAST_EXPECT(scEnv.balance(scuBob) == amt);
-
2323  BEAST_EXPECT(scEnv.balance(scuCarol) == amt);
-
2324  }
-
2325  }
-
2326 
-
2327  // If attestation moves funds, confirm the claim ledger objects are
-
2328  // removed (for both account create and "regular" transactions)
-
2329  // [greg] we do this in all attestation tests
-
2330 
-
2331  // coverage test: add_attestation transaction with incorrect flag
-
2332  {
-
2333  XEnv scEnv(*this, true);
-
2334  scEnv.tx(create_bridge(Account::master, jvb))
-
2335  .tx(jtx::signers(Account::master, quorum, signers))
-
2336  .close()
-
2337  .tx(claim_attestation(
-
2338  scAttester,
-
2339  jvb,
-
2340  mcAlice,
-
2341  XRP(1000),
-
2342  payees[0],
-
2343  true,
-
2344  1,
-
2345  {},
-
2346  signers[0]),
-
2347  txflags(tfFillOrKill),
-
2348  ter(temINVALID_FLAG))
-
2349  .close();
-
2350  }
-
2351 
-
2352  // coverage test: add_attestation with xchain feature
-
2353  // disabled
-
2354  {
-
2355  XEnv scEnv(*this, true);
-
2356  scEnv.tx(create_bridge(Account::master, jvb))
-
2357  .tx(jtx::signers(Account::master, quorum, signers))
-
2358  .disableFeature(featureXChainBridge)
-
2359  .close()
-
2360  .tx(claim_attestation(
-
2361  scAttester,
-
2362  jvb,
-
2363  mcAlice,
-
2364  XRP(1000),
-
2365  payees[0],
-
2366  true,
-
2367  1,
-
2368  {},
-
2369  signers[0]),
-
2370  ter(temDISABLED))
-
2371  .close();
-
2372  }
-
2373  }
-
2374 
-
2375  void
-
2376  testXChainAddClaimNonBatchAttestation()
-
2377  {
-
2378  using namespace jtx;
-
2379 
-
2380  testcase("Add Non Batch Claim Attestation");
-
2381 
-
2382  {
-
2383  XEnv mcEnv(*this);
-
2384  XEnv scEnv(*this, true);
-
2385  std::uint32_t const claimID = 1;
+
2305  scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 1, 3))
+
2306  .multiTx(
+
2307  att_create_acct_vec(1, amt, scuAlice, 1, 3),
+
2308  ter(tecXCHAIN_ACCOUNT_CREATE_PAST))
+
2309  .close();
+
2310  txCount += 2;
+
2311 
+
2312  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 2), "claim id 2 deleted");
+
2313  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 1), "claim id 1 not added");
+
2314  BEAST_EXPECTS(
+
2315  scEnv.claimCount(jvb) == 2, "scuAlice & scuBob created");
+
2316 
+
2317  scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1, 0))
+
2318  .close();
+
2319  txCount += 1;
+
2320 
+
2321  BEAST_EXPECTS(!scEnv.caClaimID(jvb, 3), "claim id 3 deleted");
+
2322  BEAST_EXPECTS(
+
2323  scEnv.claimCount(jvb) == 3, "All 3 accounts created");
+
2324 
+
2325  // because of the division of the rewards among attesters,
+
2326  // sometimes a couple drops are left over unspent in the
+
2327  // door account (here 2 drops)
+
2328  BEAST_EXPECT(
+
2329  multiply(amt_plus_reward, STAmount(3), xrpIssue()) +
+
2330  door.diff() <
+
2331  drops(3));
+
2332  BEAST_EXPECT(attester.diff() == -multiTtxFee(txCount));
+
2333  BEAST_EXPECT(scEnv.balance(scuAlice) == amt);
+
2334  BEAST_EXPECT(scEnv.balance(scuBob) == amt);
+
2335  BEAST_EXPECT(scEnv.balance(scuCarol) == amt);
+
2336  }
+
2337  }
+
2338 
+
2339  // If attestation moves funds, confirm the claim ledger objects are
+
2340  // removed (for both account create and "regular" transactions)
+
2341  // [greg] we do this in all attestation tests
+
2342 
+
2343  // coverage test: add_attestation transaction with incorrect flag
+
2344  {
+
2345  XEnv scEnv(*this, true);
+
2346  scEnv.tx(create_bridge(Account::master, jvb))
+
2347  .tx(jtx::signers(Account::master, quorum, signers))
+
2348  .close()
+
2349  .tx(claim_attestation(
+
2350  scAttester,
+
2351  jvb,
+
2352  mcAlice,
+
2353  XRP(1000),
+
2354  payees[0],
+
2355  true,
+
2356  1,
+
2357  {},
+
2358  signers[0]),
+
2359  txflags(tfFillOrKill),
+
2360  ter(temINVALID_FLAG))
+
2361  .close();
+
2362  }
+
2363 
+
2364  // coverage test: add_attestation with xchain feature
+
2365  // disabled
+
2366  {
+
2367  XEnv scEnv(*this, true);
+
2368  scEnv.tx(create_bridge(Account::master, jvb))
+
2369  .tx(jtx::signers(Account::master, quorum, signers))
+
2370  .disableFeature(featureXChainBridge)
+
2371  .close()
+
2372  .tx(claim_attestation(
+
2373  scAttester,
+
2374  jvb,
+
2375  mcAlice,
+
2376  XRP(1000),
+
2377  payees[0],
+
2378  true,
+
2379  1,
+
2380  {},
+
2381  signers[0]),
+
2382  ter(temDISABLED))
+
2383  .close();
+
2384  }
+
2385  }
2386 
-
2387  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
2388 
-
2389  scEnv.tx(create_bridge(Account::master, jvb))
-
2390  .tx(jtx::signers(Account::master, quorum, signers))
-
2391  .close()
-
2392  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2393  .close();
-
2394 
-
2395  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
-
2396 
-
2397  Account const dst{scBob};
-
2398  auto const amt = XRP(1000);
-
2399  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2387  void
+
2388  testXChainAddClaimNonBatchAttestation()
+
2389  {
+
2390  using namespace jtx;
+
2391 
+
2392  testcase("Add Non Batch Claim Attestation");
+
2393 
+
2394  {
+
2395  XEnv mcEnv(*this);
+
2396  XEnv scEnv(*this, true);
+
2397  std::uint32_t const claimID = 1;
+
2398 
+
2399  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
2400 
-
2401  auto const dstStartBalance = scEnv.env_.balance(dst);
-
2402 
-
2403  for (int i = 0; i < signers.size(); ++i)
-
2404  {
-
2405  auto const att = claim_attestation(
-
2406  scAttester,
-
2407  jvb,
-
2408  mcAlice,
-
2409  amt,
-
2410  payees[i],
-
2411  true,
-
2412  claimID,
-
2413  dst,
-
2414  signers[i]);
-
2415 
-
2416  TER const expectedTER =
-
2417  i < quorum ? tesSUCCESS : TER{tecXCHAIN_NO_CLAIM_ID};
-
2418  if (i + 1 == quorum)
-
2419  scEnv.tx(att, ter(expectedTER)).close();
-
2420  else
-
2421  scEnv.tx(att, ter(expectedTER)).close();
-
2422 
-
2423  if (i + 1 < quorum)
-
2424  BEAST_EXPECT(dstStartBalance == scEnv.env_.balance(dst));
-
2425  else
-
2426  BEAST_EXPECT(
-
2427  dstStartBalance + amt == scEnv.env_.balance(dst));
-
2428  }
-
2429  BEAST_EXPECT(dstStartBalance + amt == scEnv.env_.balance(dst));
-
2430  }
-
2431 
-
2432  {
-
2449  XEnv mcEnv(*this);
-
2450  XEnv scEnv(*this, true);
-
2451  auto const amt = XRP(1000);
-
2452  std::uint32_t const claimID = 1;
-
2453 
-
2454  for (auto i = 0; i < UT_XCHAIN_DEFAULT_NUM_SIGNERS - 2; ++i)
-
2455  scEnv.fund(amt, alt_signers[i].account);
-
2456 
-
2457  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
2458 
-
2459  scEnv.tx(create_bridge(Account::master, jvb))
-
2460  .tx(jtx::signers(Account::master, quorum, alt_signers))
-
2461  .close()
-
2462  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2463  .close();
-
2464 
-
2465  Account const dst{scBob};
-
2466  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
2467  auto const dstStartBalance = scEnv.env_.balance(dst);
+
2401  scEnv.tx(create_bridge(Account::master, jvb))
+
2402  .tx(jtx::signers(Account::master, quorum, signers))
+
2403  .close()
+
2404  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2405  .close();
+
2406 
+
2407  BEAST_EXPECT(!!scEnv.claimID(jvb, claimID)); // claim id present
+
2408 
+
2409  Account const dst{scBob};
+
2410  auto const amt = XRP(1000);
+
2411  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2412 
+
2413  auto const dstStartBalance = scEnv.env_.balance(dst);
+
2414 
+
2415  for (int i = 0; i < signers.size(); ++i)
+
2416  {
+
2417  auto const att = claim_attestation(
+
2418  scAttester,
+
2419  jvb,
+
2420  mcAlice,
+
2421  amt,
+
2422  payees[i],
+
2423  true,
+
2424  claimID,
+
2425  dst,
+
2426  signers[i]);
+
2427 
+
2428  TER const expectedTER =
+
2429  i < quorum ? tesSUCCESS : TER{tecXCHAIN_NO_CLAIM_ID};
+
2430  if (i + 1 == quorum)
+
2431  scEnv.tx(att, ter(expectedTER)).close();
+
2432  else
+
2433  scEnv.tx(att, ter(expectedTER)).close();
+
2434 
+
2435  if (i + 1 < quorum)
+
2436  BEAST_EXPECT(dstStartBalance == scEnv.env_.balance(dst));
+
2437  else
+
2438  BEAST_EXPECT(
+
2439  dstStartBalance + amt == scEnv.env_.balance(dst));
+
2440  }
+
2441  BEAST_EXPECT(dstStartBalance + amt == scEnv.env_.balance(dst));
+
2442  }
+
2443 
+
2444  {
+
2461  XEnv mcEnv(*this);
+
2462  XEnv scEnv(*this, true);
+
2463  auto const amt = XRP(1000);
+
2464  std::uint32_t const claimID = 1;
+
2465 
+
2466  for (auto i = 0; i < UT_XCHAIN_DEFAULT_NUM_SIGNERS - 2; ++i)
+
2467  scEnv.fund(amt, alt_signers[i].account);
2468 
-
2469  {
-
2470  // G1: master key
-
2471  auto att = claim_attestation(
-
2472  scAttester,
-
2473  jvb,
-
2474  mcAlice,
-
2475  amt,
-
2476  payees[0],
-
2477  true,
-
2478  claimID,
-
2479  dst,
-
2480  alt_signers[0]);
-
2481  scEnv.tx(att).close();
-
2482  }
-
2483  {
-
2484  // G2: regular key
-
2485  // alt_signers[0] is the regular key of alt_signers[1]
-
2486  // There should be 2 attestations after the transaction
-
2487  scEnv
-
2488  .tx(jtx::regkey(
-
2489  alt_signers[1].account, alt_signers[0].account))
-
2490  .close();
-
2491  auto att = claim_attestation(
-
2492  scAttester,
-
2493  jvb,
-
2494  mcAlice,
-
2495  amt,
-
2496  payees[1],
-
2497  true,
-
2498  claimID,
-
2499  dst,
-
2500  alt_signers[0]);
-
2501  att[sfAttestationSignerAccount.getJsonName()] =
-
2502  alt_signers[1].account.human();
-
2503  scEnv.tx(att).close();
-
2504  }
-
2505  {
-
2506  // B3: public key and non-exist (unfunded) account mismatch
-
2507  // G3: public key and non-exist (unfunded) account match
-
2508  auto const unfundedSigner1 =
-
2509  alt_signers[UT_XCHAIN_DEFAULT_NUM_SIGNERS - 1];
-
2510  auto const unfundedSigner2 =
-
2511  alt_signers[UT_XCHAIN_DEFAULT_NUM_SIGNERS - 2];
-
2512  auto att = claim_attestation(
-
2513  scAttester,
-
2514  jvb,
-
2515  mcAlice,
-
2516  amt,
-
2517  payees[UT_XCHAIN_DEFAULT_NUM_SIGNERS - 1],
-
2518  true,
-
2519  claimID,
-
2520  dst,
-
2521  unfundedSigner1);
-
2522  att[sfAttestationSignerAccount.getJsonName()] =
-
2523  unfundedSigner2.account.human();
-
2524  scEnv.tx(att, ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR))
-
2525  .close();
-
2526  att[sfAttestationSignerAccount.getJsonName()] =
-
2527  unfundedSigner1.account.human();
-
2528  scEnv.tx(att).close();
-
2529  }
-
2530  {
-
2531  // B2: single item signer list
-
2532  std::vector<signer> tempSignerList = {signers[0]};
-
2533  scEnv.tx(
-
2534  jtx::signers(alt_signers[2].account, 1, tempSignerList));
-
2535  auto att = claim_attestation(
-
2536  scAttester,
-
2537  jvb,
-
2538  mcAlice,
-
2539  amt,
-
2540  payees[2],
-
2541  true,
-
2542  claimID,
-
2543  dst,
-
2544  tempSignerList.front());
-
2545  att[sfAttestationSignerAccount.getJsonName()] =
-
2546  alt_signers[2].account.human();
-
2547  scEnv.tx(att, ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR))
-
2548  .close();
-
2549  }
-
2550  {
-
2551  // B1: disabled master key
-
2552  scEnv.tx(fset(alt_signers[2].account, asfDisableMaster, 0));
-
2553  auto att = claim_attestation(
-
2554  scAttester,
-
2555  jvb,
-
2556  mcAlice,
-
2557  amt,
-
2558  payees[2],
-
2559  true,
-
2560  claimID,
-
2561  dst,
-
2562  alt_signers[2]);
-
2563  scEnv.tx(att, ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR))
-
2564  .close();
-
2565  }
-
2566  {
-
2567  // --B4: not on signer list
-
2568  auto att = claim_attestation(
-
2569  scAttester,
-
2570  jvb,
-
2571  mcAlice,
-
2572  amt,
-
2573  payees[0],
-
2574  true,
-
2575  claimID,
-
2576  dst,
-
2577  signers[0]);
-
2578  scEnv.tx(att, ter(tecNO_PERMISSION)).close();
-
2579  }
-
2580  {
-
2581  // --B5: missing sfAttestationSignerAccount field
-
2582  // Then submit the one with the field. Should rearch quorum.
-
2583  auto att = claim_attestation(
-
2584  scAttester,
-
2585  jvb,
-
2586  mcAlice,
-
2587  amt,
-
2588  payees[3],
-
2589  true,
-
2590  claimID,
-
2591  dst,
-
2592  alt_signers[3]);
-
2593  att.removeMember(sfAttestationSignerAccount.getJsonName());
-
2594  scEnv.tx(att, ter(temMALFORMED)).close();
-
2595  BEAST_EXPECT(dstStartBalance == scEnv.env_.balance(dst));
-
2596  att[sfAttestationSignerAccount.getJsonName()] =
-
2597  alt_signers[3].account.human();
-
2598  scEnv.tx(att).close();
-
2599  BEAST_EXPECT(dstStartBalance + amt == scEnv.env_.balance(dst));
-
2600  }
-
2601  }
-
2602  }
-
2603 
-
2604  void
-
2605  testXChainAddAccountCreateNonBatchAttestation()
-
2606  {
-
2607  using namespace jtx;
-
2608 
-
2609  testcase("Add Non Batch Account Create Attestation");
-
2610 
-
2611  XEnv mcEnv(*this);
-
2612  XEnv scEnv(*this, true);
-
2613 
-
2614  XRPAmount tx_fee = mcEnv.txFee();
+
2469  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2470 
+
2471  scEnv.tx(create_bridge(Account::master, jvb))
+
2472  .tx(jtx::signers(Account::master, quorum, alt_signers))
+
2473  .close()
+
2474  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2475  .close();
+
2476 
+
2477  Account const dst{scBob};
+
2478  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2479  auto const dstStartBalance = scEnv.env_.balance(dst);
+
2480 
+
2481  {
+
2482  // G1: master key
+
2483  auto att = claim_attestation(
+
2484  scAttester,
+
2485  jvb,
+
2486  mcAlice,
+
2487  amt,
+
2488  payees[0],
+
2489  true,
+
2490  claimID,
+
2491  dst,
+
2492  alt_signers[0]);
+
2493  scEnv.tx(att).close();
+
2494  }
+
2495  {
+
2496  // G2: regular key
+
2497  // alt_signers[0] is the regular key of alt_signers[1]
+
2498  // There should be 2 attestations after the transaction
+
2499  scEnv
+
2500  .tx(jtx::regkey(
+
2501  alt_signers[1].account, alt_signers[0].account))
+
2502  .close();
+
2503  auto att = claim_attestation(
+
2504  scAttester,
+
2505  jvb,
+
2506  mcAlice,
+
2507  amt,
+
2508  payees[1],
+
2509  true,
+
2510  claimID,
+
2511  dst,
+
2512  alt_signers[0]);
+
2513  att[sfAttestationSignerAccount.getJsonName()] =
+
2514  alt_signers[1].account.human();
+
2515  scEnv.tx(att).close();
+
2516  }
+
2517  {
+
2518  // B3: public key and non-exist (unfunded) account mismatch
+
2519  // G3: public key and non-exist (unfunded) account match
+
2520  auto const unfundedSigner1 =
+
2521  alt_signers[UT_XCHAIN_DEFAULT_NUM_SIGNERS - 1];
+
2522  auto const unfundedSigner2 =
+
2523  alt_signers[UT_XCHAIN_DEFAULT_NUM_SIGNERS - 2];
+
2524  auto att = claim_attestation(
+
2525  scAttester,
+
2526  jvb,
+
2527  mcAlice,
+
2528  amt,
+
2529  payees[UT_XCHAIN_DEFAULT_NUM_SIGNERS - 1],
+
2530  true,
+
2531  claimID,
+
2532  dst,
+
2533  unfundedSigner1);
+
2534  att[sfAttestationSignerAccount.getJsonName()] =
+
2535  unfundedSigner2.account.human();
+
2536  scEnv.tx(att, ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR))
+
2537  .close();
+
2538  att[sfAttestationSignerAccount.getJsonName()] =
+
2539  unfundedSigner1.account.human();
+
2540  scEnv.tx(att).close();
+
2541  }
+
2542  {
+
2543  // B2: single item signer list
+
2544  std::vector<signer> tempSignerList = {signers[0]};
+
2545  scEnv.tx(
+
2546  jtx::signers(alt_signers[2].account, 1, tempSignerList));
+
2547  auto att = claim_attestation(
+
2548  scAttester,
+
2549  jvb,
+
2550  mcAlice,
+
2551  amt,
+
2552  payees[2],
+
2553  true,
+
2554  claimID,
+
2555  dst,
+
2556  tempSignerList.front());
+
2557  att[sfAttestationSignerAccount.getJsonName()] =
+
2558  alt_signers[2].account.human();
+
2559  scEnv.tx(att, ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR))
+
2560  .close();
+
2561  }
+
2562  {
+
2563  // B1: disabled master key
+
2564  scEnv.tx(fset(alt_signers[2].account, asfDisableMaster, 0));
+
2565  auto att = claim_attestation(
+
2566  scAttester,
+
2567  jvb,
+
2568  mcAlice,
+
2569  amt,
+
2570  payees[2],
+
2571  true,
+
2572  claimID,
+
2573  dst,
+
2574  alt_signers[2]);
+
2575  scEnv.tx(att, ter(tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR))
+
2576  .close();
+
2577  }
+
2578  {
+
2579  // --B4: not on signer list
+
2580  auto att = claim_attestation(
+
2581  scAttester,
+
2582  jvb,
+
2583  mcAlice,
+
2584  amt,
+
2585  payees[0],
+
2586  true,
+
2587  claimID,
+
2588  dst,
+
2589  signers[0]);
+
2590  scEnv.tx(att, ter(tecNO_PERMISSION)).close();
+
2591  }
+
2592  {
+
2593  // --B5: missing sfAttestationSignerAccount field
+
2594  // Then submit the one with the field. Should rearch quorum.
+
2595  auto att = claim_attestation(
+
2596  scAttester,
+
2597  jvb,
+
2598  mcAlice,
+
2599  amt,
+
2600  payees[3],
+
2601  true,
+
2602  claimID,
+
2603  dst,
+
2604  alt_signers[3]);
+
2605  att.removeMember(sfAttestationSignerAccount.getJsonName());
+
2606  scEnv.tx(att, ter(temMALFORMED)).close();
+
2607  BEAST_EXPECT(dstStartBalance == scEnv.env_.balance(dst));
+
2608  att[sfAttestationSignerAccount.getJsonName()] =
+
2609  alt_signers[3].account.human();
+
2610  scEnv.tx(att).close();
+
2611  BEAST_EXPECT(dstStartBalance + amt == scEnv.env_.balance(dst));
+
2612  }
+
2613  }
+
2614  }
2615 
-
2616  Account a{"a"};
-
2617  Account doorA{"doorA"};
-
2618 
-
2619  STAmount funds{XRP(10000)};
-
2620  mcEnv.fund(funds, a);
-
2621  mcEnv.fund(funds, doorA);
+
2616  void
+
2617  testXChainAddAccountCreateNonBatchAttestation()
+
2618  {
+
2619  using namespace jtx;
+
2620 
+
2621  testcase("Add Non Batch Account Create Attestation");
2622 
-
2623  Account ua{"ua"}; // unfunded account we want to create
-
2624 
-
2625  BridgeDef xrp_b{
-
2626  doorA,
-
2627  xrpIssue(),
-
2628  Account::master,
-
2629  xrpIssue(),
-
2630  XRP(1), // reward
-
2631  XRP(20), // minAccountCreate
-
2632  4, // quorum
-
2633  signers,
-
2634  Json::nullValue};
-
2635 
-
2636  xrp_b.initBridge(mcEnv, scEnv);
-
2637 
-
2638  auto const amt = XRP(777);
-
2639  auto const amt_plus_reward = amt + xrp_b.reward;
-
2640  {
-
2641  Balance bal_doorA(mcEnv, doorA);
-
2642  Balance bal_a(mcEnv, a);
-
2643 
-
2644  mcEnv
-
2645  .tx(sidechain_xchain_account_create(
-
2646  a, xrp_b.jvb, ua, amt, xrp_b.reward))
-
2647  .close();
-
2648 
-
2649  BEAST_EXPECT(bal_doorA.diff() == amt_plus_reward);
-
2650  BEAST_EXPECT(bal_a.diff() == -(amt_plus_reward + tx_fee));
-
2651  }
-
2652 
-
2653  for (int i = 0; i < signers.size(); ++i)
-
2654  {
-
2655  auto const att = create_account_attestation(
-
2656  signers[0].account,
-
2657  xrp_b.jvb,
-
2658  a,
-
2659  amt,
-
2660  xrp_b.reward,
-
2661  signers[i].account,
-
2662  true,
-
2663  1,
-
2664  ua,
-
2665  signers[i]);
-
2666  TER const expectedTER = i < xrp_b.quorum
-
2667  ? tesSUCCESS
-
2668  : TER{tecXCHAIN_ACCOUNT_CREATE_PAST};
-
2669 
-
2670  scEnv.tx(att, ter(expectedTER)).close();
-
2671  if (i + 1 < xrp_b.quorum)
-
2672  BEAST_EXPECT(!scEnv.env_.le(ua));
-
2673  else
-
2674  BEAST_EXPECT(scEnv.env_.le(ua));
-
2675  }
-
2676  BEAST_EXPECT(scEnv.env_.le(ua));
-
2677  }
-
2678 
-
2679  void
-
2680  testXChainClaim()
-
2681  {
-
2682  using namespace jtx;
-
2683 
-
2684  XRPAmount res0 = reserve(0);
-
2685  XRPAmount tx_fee = txFee();
-
2686 
-
2687  testcase("Claim");
-
2688 
-
2689  // Claim where the amount matches what is attested to, to an account
-
2690  // that exists, and there are enough attestations to reach a quorum
-
2691  // => should succeed
-
2692  // -----------------------------------------------------------------
-
2693  for (auto withClaim : {false, true})
-
2694  {
-
2695  XEnv mcEnv(*this);
-
2696  XEnv scEnv(*this, true);
-
2697 
-
2698  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
2699 
-
2700  scEnv.tx(create_bridge(Account::master, jvb))
-
2701  .tx(jtx::signers(Account::master, quorum, signers))
-
2702  .close()
-
2703  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2704  .close();
-
2705 
-
2706  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
2707  auto const amt = XRP(1000);
-
2708  std::uint32_t const claimID = 1;
-
2709  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
2710 
-
2711  BalanceTransfer transfer(
-
2712  scEnv,
-
2713  Account::master,
-
2714  scBob,
-
2715  scAlice,
-
2716  &payees[0],
-
2717  UT_XCHAIN_DEFAULT_QUORUM,
-
2718  withClaim);
-
2719 
-
2720  scEnv
-
2721  .multiTx(claim_attestations(
-
2722  scAttester,
-
2723  jvb,
-
2724  mcAlice,
-
2725  amt,
-
2726  payees,
-
2727  true,
-
2728  claimID,
-
2729  dst,
-
2730  signers))
-
2731  .close();
-
2732  if (withClaim)
-
2733  {
-
2734  BEAST_EXPECT(transfer.has_not_happened());
-
2735 
-
2736  // need to submit a claim transactions
-
2737  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
2738  .close();
-
2739  }
-
2740 
-
2741  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
2742  }
-
2743 
-
2744  // Claim with just one attestation signed by the Master key
-
2745  // => should not succeed
-
2746  // -----------------------------------------------------------------
-
2747  for (auto withClaim : {false, true})
-
2748  {
-
2749  XEnv mcEnv(*this);
-
2750  XEnv scEnv(*this, true);
-
2751 
-
2752  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
2753 
-
2754  scEnv
-
2755  .tx(create_bridge(Account::master, jvb))
-
2756  //.tx(jtx::signers(Account::master, quorum, signers))
-
2757  .close()
-
2758  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2759  .close();
-
2760 
-
2761  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
2762  auto const amt = XRP(1000);
-
2763  std::uint32_t const claimID = 1;
-
2764  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2623  XEnv mcEnv(*this);
+
2624  XEnv scEnv(*this, true);
+
2625 
+
2626  XRPAmount tx_fee = mcEnv.txFee();
+
2627 
+
2628  Account a{"a"};
+
2629  Account doorA{"doorA"};
+
2630 
+
2631  STAmount funds{XRP(10000)};
+
2632  mcEnv.fund(funds, a);
+
2633  mcEnv.fund(funds, doorA);
+
2634 
+
2635  Account ua{"ua"}; // unfunded account we want to create
+
2636 
+
2637  BridgeDef xrp_b{
+
2638  doorA,
+
2639  xrpIssue(),
+
2640  Account::master,
+
2641  xrpIssue(),
+
2642  XRP(1), // reward
+
2643  XRP(20), // minAccountCreate
+
2644  4, // quorum
+
2645  signers,
+
2646  Json::nullValue};
+
2647 
+
2648  xrp_b.initBridge(mcEnv, scEnv);
+
2649 
+
2650  auto const amt = XRP(777);
+
2651  auto const amt_plus_reward = amt + xrp_b.reward;
+
2652  {
+
2653  Balance bal_doorA(mcEnv, doorA);
+
2654  Balance bal_a(mcEnv, a);
+
2655 
+
2656  mcEnv
+
2657  .tx(sidechain_xchain_account_create(
+
2658  a, xrp_b.jvb, ua, amt, xrp_b.reward))
+
2659  .close();
+
2660 
+
2661  BEAST_EXPECT(bal_doorA.diff() == amt_plus_reward);
+
2662  BEAST_EXPECT(bal_a.diff() == -(amt_plus_reward + tx_fee));
+
2663  }
+
2664 
+
2665  for (int i = 0; i < signers.size(); ++i)
+
2666  {
+
2667  auto const att = create_account_attestation(
+
2668  signers[0].account,
+
2669  xrp_b.jvb,
+
2670  a,
+
2671  amt,
+
2672  xrp_b.reward,
+
2673  signers[i].account,
+
2674  true,
+
2675  1,
+
2676  ua,
+
2677  signers[i]);
+
2678  TER const expectedTER = i < xrp_b.quorum
+
2679  ? tesSUCCESS
+
2680  : TER{tecXCHAIN_ACCOUNT_CREATE_PAST};
+
2681 
+
2682  scEnv.tx(att, ter(expectedTER)).close();
+
2683  if (i + 1 < xrp_b.quorum)
+
2684  BEAST_EXPECT(!scEnv.env_.le(ua));
+
2685  else
+
2686  BEAST_EXPECT(scEnv.env_.le(ua));
+
2687  }
+
2688  BEAST_EXPECT(scEnv.env_.le(ua));
+
2689  }
+
2690 
+
2691  void
+
2692  testXChainClaim()
+
2693  {
+
2694  using namespace jtx;
+
2695 
+
2696  XRPAmount res0 = reserve(0);
+
2697  XRPAmount tx_fee = txFee();
+
2698 
+
2699  testcase("Claim");
+
2700 
+
2701  // Claim where the amount matches what is attested to, to an account
+
2702  // that exists, and there are enough attestations to reach a quorum
+
2703  // => should succeed
+
2704  // -----------------------------------------------------------------
+
2705  for (auto withClaim : {false, true})
+
2706  {
+
2707  XEnv mcEnv(*this);
+
2708  XEnv scEnv(*this, true);
+
2709 
+
2710  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2711 
+
2712  scEnv.tx(create_bridge(Account::master, jvb))
+
2713  .tx(jtx::signers(Account::master, quorum, signers))
+
2714  .close()
+
2715  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2716  .close();
+
2717 
+
2718  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
2719  auto const amt = XRP(1000);
+
2720  std::uint32_t const claimID = 1;
+
2721  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2722 
+
2723  BalanceTransfer transfer(
+
2724  scEnv,
+
2725  Account::master,
+
2726  scBob,
+
2727  scAlice,
+
2728  &payees[0],
+
2729  UT_XCHAIN_DEFAULT_QUORUM,
+
2730  withClaim);
+
2731 
+
2732  scEnv
+
2733  .multiTx(claim_attestations(
+
2734  scAttester,
+
2735  jvb,
+
2736  mcAlice,
+
2737  amt,
+
2738  payees,
+
2739  true,
+
2740  claimID,
+
2741  dst,
+
2742  signers))
+
2743  .close();
+
2744  if (withClaim)
+
2745  {
+
2746  BEAST_EXPECT(transfer.has_not_happened());
+
2747 
+
2748  // need to submit a claim transactions
+
2749  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
2750  .close();
+
2751  }
+
2752 
+
2753  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
2754  }
+
2755 
+
2756  // Claim with just one attestation signed by the Master key
+
2757  // => should not succeed
+
2758  // -----------------------------------------------------------------
+
2759  for (auto withClaim : {false, true})
+
2760  {
+
2761  XEnv mcEnv(*this);
+
2762  XEnv scEnv(*this, true);
+
2763 
+
2764  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
2765 
-
2766  BalanceTransfer transfer(
-
2767  scEnv,
-
2768  Account::master,
-
2769  scBob,
-
2770  scAlice,
-
2771  &payees[0],
-
2772  1,
-
2773  withClaim);
-
2774 
-
2775  jtx::signer master_signer(Account::master);
-
2776  scEnv
-
2777  .tx(claim_attestation(
-
2778  scAttester,
-
2779  jvb,
-
2780  mcAlice,
-
2781  amt,
-
2782  payees[0],
-
2783  true,
-
2784  claimID,
-
2785  dst,
-
2786  master_signer),
-
2787  ter(tecXCHAIN_NO_SIGNERS_LIST))
-
2788  .close();
-
2789 
-
2790  BEAST_EXPECT(transfer.has_not_happened());
-
2791  }
-
2792 
-
2793  // Claim with just one attestation signed by a regular key
-
2794  // associated to the master account
-
2795  // => should not succeed
-
2796  // -----------------------------------------------------------------
-
2797  for (auto withClaim : {false, true})
-
2798  {
-
2799  XEnv mcEnv(*this);
-
2800  XEnv scEnv(*this, true);
+
2766  scEnv
+
2767  .tx(create_bridge(Account::master, jvb))
+
2768  //.tx(jtx::signers(Account::master, quorum, signers))
+
2769  .close()
+
2770  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2771  .close();
+
2772 
+
2773  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
2774  auto const amt = XRP(1000);
+
2775  std::uint32_t const claimID = 1;
+
2776  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2777 
+
2778  BalanceTransfer transfer(
+
2779  scEnv,
+
2780  Account::master,
+
2781  scBob,
+
2782  scAlice,
+
2783  &payees[0],
+
2784  1,
+
2785  withClaim);
+
2786 
+
2787  jtx::signer master_signer(Account::master);
+
2788  scEnv
+
2789  .tx(claim_attestation(
+
2790  scAttester,
+
2791  jvb,
+
2792  mcAlice,
+
2793  amt,
+
2794  payees[0],
+
2795  true,
+
2796  claimID,
+
2797  dst,
+
2798  master_signer),
+
2799  ter(tecXCHAIN_NO_SIGNERS_LIST))
+
2800  .close();
2801 
-
2802  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
2803 
-
2804  scEnv
-
2805  .tx(create_bridge(Account::master, jvb))
-
2806  //.tx(jtx::signers(Account::master, quorum, signers))
-
2807  .tx(jtx::regkey(Account::master, payees[0]))
-
2808  .close()
-
2809  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2810  .close();
-
2811 
-
2812  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
2813  auto const amt = XRP(1000);
-
2814  std::uint32_t const claimID = 1;
-
2815  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
2816 
-
2817  BalanceTransfer transfer(
-
2818  scEnv,
-
2819  Account::master,
-
2820  scBob,
-
2821  scAlice,
-
2822  &payees[0],
-
2823  1,
-
2824  withClaim);
-
2825 
-
2826  jtx::signer master_signer(payees[0]);
-
2827  scEnv
-
2828  .tx(claim_attestation(
-
2829  scAttester,
-
2830  jvb,
-
2831  mcAlice,
-
2832  amt,
-
2833  payees[0],
-
2834  true,
-
2835  claimID,
-
2836  dst,
-
2837  master_signer),
-
2838  ter(tecXCHAIN_NO_SIGNERS_LIST))
-
2839  .close();
-
2840 
-
2841  BEAST_EXPECT(transfer.has_not_happened());
-
2842  }
-
2843 
-
2844  // Claim against non-existent bridge
-
2845  // ---------------------------------
-
2846  for (auto withClaim : {false, true})
-
2847  {
-
2848  XEnv mcEnv(*this);
-
2849  XEnv scEnv(*this, true);
-
2850 
-
2851  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2802  BEAST_EXPECT(transfer.has_not_happened());
+
2803  }
+
2804 
+
2805  // Claim with just one attestation signed by a regular key
+
2806  // associated to the master account
+
2807  // => should not succeed
+
2808  // -----------------------------------------------------------------
+
2809  for (auto withClaim : {false, true})
+
2810  {
+
2811  XEnv mcEnv(*this);
+
2812  XEnv scEnv(*this, true);
+
2813 
+
2814  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2815 
+
2816  scEnv
+
2817  .tx(create_bridge(Account::master, jvb))
+
2818  //.tx(jtx::signers(Account::master, quorum, signers))
+
2819  .tx(jtx::regkey(Account::master, payees[0]))
+
2820  .close()
+
2821  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2822  .close();
+
2823 
+
2824  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
2825  auto const amt = XRP(1000);
+
2826  std::uint32_t const claimID = 1;
+
2827  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2828 
+
2829  BalanceTransfer transfer(
+
2830  scEnv,
+
2831  Account::master,
+
2832  scBob,
+
2833  scAlice,
+
2834  &payees[0],
+
2835  1,
+
2836  withClaim);
+
2837 
+
2838  jtx::signer master_signer(payees[0]);
+
2839  scEnv
+
2840  .tx(claim_attestation(
+
2841  scAttester,
+
2842  jvb,
+
2843  mcAlice,
+
2844  amt,
+
2845  payees[0],
+
2846  true,
+
2847  claimID,
+
2848  dst,
+
2849  master_signer),
+
2850  ter(tecXCHAIN_NO_SIGNERS_LIST))
+
2851  .close();
2852 
-
2853  auto jvb_unknown =
-
2854  bridge(mcBob, xrpIssue(), Account::master, xrpIssue());
+
2853  BEAST_EXPECT(transfer.has_not_happened());
+
2854  }
2855 
-
2856  scEnv.tx(create_bridge(Account::master, jvb))
-
2857  .tx(jtx::signers(Account::master, quorum, signers))
-
2858  .close()
-
2859  .tx(xchain_create_claim_id(
-
2860  scAlice, jvb_unknown, reward, mcAlice),
-
2861  ter(tecNO_ENTRY))
-
2862  .close();
-
2863 
-
2864  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
2865  auto const amt = XRP(1000);
-
2866  std::uint32_t const claimID = 1;
-
2867  mcEnv
-
2868  .tx(xchain_commit(mcAlice, jvb_unknown, claimID, amt, dst),
-
2869  ter(tecNO_ENTRY))
-
2870  .close();
-
2871 
-
2872  BalanceTransfer transfer(
-
2873  scEnv, Account::master, scBob, scAlice, payees, withClaim);
-
2874  scEnv
-
2875  .tx(claim_attestation(
-
2876  scAttester,
-
2877  jvb_unknown,
-
2878  mcAlice,
-
2879  amt,
-
2880  payees[0],
-
2881  true,
-
2882  claimID,
-
2883  dst,
-
2884  signers[0]),
-
2885  ter(tecNO_ENTRY))
-
2886  .close();
-
2887 
-
2888  if (withClaim)
-
2889  {
-
2890  BEAST_EXPECT(transfer.has_not_happened());
-
2891 
-
2892  // need to submit a claim transactions
-
2893  scEnv
-
2894  .tx(xchain_claim(scAlice, jvb_unknown, claimID, amt, scBob),
-
2895  ter(tecNO_ENTRY))
-
2896  .close();
-
2897  }
-
2898 
-
2899  BEAST_EXPECT(transfer.has_not_happened());
-
2900  }
-
2901 
-
2902  // Claim against non-existent claim id
-
2903  // -----------------------------------
-
2904  for (auto withClaim : {false, true})
-
2905  {
-
2906  XEnv mcEnv(*this);
-
2907  XEnv scEnv(*this, true);
-
2908 
-
2909  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2856  // Claim against non-existent bridge
+
2857  // ---------------------------------
+
2858  for (auto withClaim : {false, true})
+
2859  {
+
2860  XEnv mcEnv(*this);
+
2861  XEnv scEnv(*this, true);
+
2862 
+
2863  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2864 
+
2865  auto jvb_unknown =
+
2866  bridge(mcBob, xrpIssue(), Account::master, xrpIssue());
+
2867 
+
2868  scEnv.tx(create_bridge(Account::master, jvb))
+
2869  .tx(jtx::signers(Account::master, quorum, signers))
+
2870  .close()
+
2871  .tx(xchain_create_claim_id(
+
2872  scAlice, jvb_unknown, reward, mcAlice),
+
2873  ter(tecNO_ENTRY))
+
2874  .close();
+
2875 
+
2876  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
2877  auto const amt = XRP(1000);
+
2878  std::uint32_t const claimID = 1;
+
2879  mcEnv
+
2880  .tx(xchain_commit(mcAlice, jvb_unknown, claimID, amt, dst),
+
2881  ter(tecNO_ENTRY))
+
2882  .close();
+
2883 
+
2884  BalanceTransfer transfer(
+
2885  scEnv, Account::master, scBob, scAlice, payees, withClaim);
+
2886  scEnv
+
2887  .tx(claim_attestation(
+
2888  scAttester,
+
2889  jvb_unknown,
+
2890  mcAlice,
+
2891  amt,
+
2892  payees[0],
+
2893  true,
+
2894  claimID,
+
2895  dst,
+
2896  signers[0]),
+
2897  ter(tecNO_ENTRY))
+
2898  .close();
+
2899 
+
2900  if (withClaim)
+
2901  {
+
2902  BEAST_EXPECT(transfer.has_not_happened());
+
2903 
+
2904  // need to submit a claim transactions
+
2905  scEnv
+
2906  .tx(xchain_claim(scAlice, jvb_unknown, claimID, amt, scBob),
+
2907  ter(tecNO_ENTRY))
+
2908  .close();
+
2909  }
2910 
-
2911  scEnv.tx(create_bridge(Account::master, jvb))
-
2912  .tx(jtx::signers(Account::master, quorum, signers))
-
2913  .close()
-
2914  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2915  .close();
-
2916 
-
2917  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
2918  auto const amt = XRP(1000);
-
2919  std::uint32_t const claimID = 1;
-
2920  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
2921 
-
2922  BalanceTransfer transfer(
-
2923  scEnv, Account::master, scBob, scAlice, payees, withClaim);
-
2924 
-
2925  // attest using non-existent claim id
-
2926  scEnv
-
2927  .tx(claim_attestation(
-
2928  scAttester,
-
2929  jvb,
-
2930  mcAlice,
-
2931  amt,
-
2932  payees[0],
-
2933  true,
-
2934  999,
-
2935  dst,
-
2936  signers[0]),
-
2937  ter(tecXCHAIN_NO_CLAIM_ID))
-
2938  .close();
-
2939  if (withClaim)
-
2940  {
-
2941  BEAST_EXPECT(transfer.has_not_happened());
-
2942 
-
2943  // claim using non-existent claim id
-
2944  scEnv
-
2945  .tx(xchain_claim(scAlice, jvb, 999, amt, scBob),
-
2946  ter(tecXCHAIN_NO_CLAIM_ID))
-
2947  .close();
-
2948  }
-
2949 
-
2950  BEAST_EXPECT(transfer.has_not_happened());
-
2951  }
-
2952 
-
2953  // Claim against a claim id owned by another account
-
2954  // -------------------------------------------------
-
2955  for (auto withClaim : {false, true})
-
2956  {
-
2957  XEnv mcEnv(*this);
-
2958  XEnv scEnv(*this, true);
-
2959 
-
2960  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2911  BEAST_EXPECT(transfer.has_not_happened());
+
2912  }
+
2913 
+
2914  // Claim against non-existent claim id
+
2915  // -----------------------------------
+
2916  for (auto withClaim : {false, true})
+
2917  {
+
2918  XEnv mcEnv(*this);
+
2919  XEnv scEnv(*this, true);
+
2920 
+
2921  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2922 
+
2923  scEnv.tx(create_bridge(Account::master, jvb))
+
2924  .tx(jtx::signers(Account::master, quorum, signers))
+
2925  .close()
+
2926  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2927  .close();
+
2928 
+
2929  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
2930  auto const amt = XRP(1000);
+
2931  std::uint32_t const claimID = 1;
+
2932  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2933 
+
2934  BalanceTransfer transfer(
+
2935  scEnv, Account::master, scBob, scAlice, payees, withClaim);
+
2936 
+
2937  // attest using non-existent claim id
+
2938  scEnv
+
2939  .tx(claim_attestation(
+
2940  scAttester,
+
2941  jvb,
+
2942  mcAlice,
+
2943  amt,
+
2944  payees[0],
+
2945  true,
+
2946  999,
+
2947  dst,
+
2948  signers[0]),
+
2949  ter(tecXCHAIN_NO_CLAIM_ID))
+
2950  .close();
+
2951  if (withClaim)
+
2952  {
+
2953  BEAST_EXPECT(transfer.has_not_happened());
+
2954 
+
2955  // claim using non-existent claim id
+
2956  scEnv
+
2957  .tx(xchain_claim(scAlice, jvb, 999, amt, scBob),
+
2958  ter(tecXCHAIN_NO_CLAIM_ID))
+
2959  .close();
+
2960  }
2961 
-
2962  scEnv.tx(create_bridge(Account::master, jvb))
-
2963  .tx(jtx::signers(Account::master, quorum, signers))
-
2964  .close()
-
2965  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
2966  .close();
-
2967 
-
2968  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
2969  auto const amt = XRP(1000);
-
2970  std::uint32_t const claimID = 1;
-
2971  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
2972 
-
2973  BalanceTransfer transfer(
-
2974  scEnv,
-
2975  Account::master,
-
2976  scBob,
-
2977  scAlice,
-
2978  &payees[0],
-
2979  UT_XCHAIN_DEFAULT_QUORUM,
-
2980  withClaim);
-
2981 
-
2982  scEnv
-
2983  .multiTx(claim_attestations(
-
2984  scAttester,
-
2985  jvb,
-
2986  mcAlice,
-
2987  amt,
-
2988  payees,
-
2989  true,
-
2990  claimID,
-
2991  dst,
-
2992  signers))
-
2993  .close();
-
2994  if (withClaim)
-
2995  {
-
2996  BEAST_EXPECT(transfer.has_not_happened());
-
2997 
-
2998  // submit a claim transaction with the wrong account (scGw
-
2999  // instead of scAlice)
-
3000  scEnv
-
3001  .tx(xchain_claim(scGw, jvb, claimID, amt, scBob),
-
3002  ter(tecXCHAIN_BAD_CLAIM_ID))
-
3003  .close();
-
3004  BEAST_EXPECT(transfer.has_not_happened());
-
3005  }
-
3006  else
+
2962  BEAST_EXPECT(transfer.has_not_happened());
+
2963  }
+
2964 
+
2965  // Claim against a claim id owned by another account
+
2966  // -------------------------------------------------
+
2967  for (auto withClaim : {false, true})
+
2968  {
+
2969  XEnv mcEnv(*this);
+
2970  XEnv scEnv(*this, true);
+
2971 
+
2972  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
2973 
+
2974  scEnv.tx(create_bridge(Account::master, jvb))
+
2975  .tx(jtx::signers(Account::master, quorum, signers))
+
2976  .close()
+
2977  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
2978  .close();
+
2979 
+
2980  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
2981  auto const amt = XRP(1000);
+
2982  std::uint32_t const claimID = 1;
+
2983  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
2984 
+
2985  BalanceTransfer transfer(
+
2986  scEnv,
+
2987  Account::master,
+
2988  scBob,
+
2989  scAlice,
+
2990  &payees[0],
+
2991  UT_XCHAIN_DEFAULT_QUORUM,
+
2992  withClaim);
+
2993 
+
2994  scEnv
+
2995  .multiTx(claim_attestations(
+
2996  scAttester,
+
2997  jvb,
+
2998  mcAlice,
+
2999  amt,
+
3000  payees,
+
3001  true,
+
3002  claimID,
+
3003  dst,
+
3004  signers))
+
3005  .close();
+
3006  if (withClaim)
3007  {
-
3008  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
3009  }
-
3010  }
-
3011 
-
3012  // Claim against a claim id with no attestations
-
3013  // ---------------------------------------------
-
3014  for (auto withClaim : {false, true})
-
3015  {
-
3016  XEnv mcEnv(*this);
-
3017  XEnv scEnv(*this, true);
-
3018 
-
3019  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3020 
-
3021  scEnv.tx(create_bridge(Account::master, jvb))
-
3022  .tx(jtx::signers(Account::master, quorum, signers))
-
3023  .close()
-
3024  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3025  .close();
-
3026 
-
3027  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3028  auto const amt = XRP(1000);
-
3029  std::uint32_t const claimID = 1;
-
3030  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3031 
-
3032  BalanceTransfer transfer(
-
3033  scEnv, Account::master, scBob, scAlice, payees, withClaim);
-
3034 
-
3035  // don't send any attestations
-
3036 
-
3037  if (withClaim)
-
3038  {
-
3039  BEAST_EXPECT(transfer.has_not_happened());
-
3040 
-
3041  // need to submit a claim transactions
-
3042  scEnv
-
3043  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3044  ter(tecXCHAIN_CLAIM_NO_QUORUM))
-
3045  .close();
-
3046  }
-
3047 
-
3048  BEAST_EXPECT(transfer.has_not_happened());
-
3049  }
-
3050 
-
3051  // Claim against a claim id with attestations, but not enough to
-
3052  // make a quorum
-
3053  // --------------------------------------------------------------------
-
3054  for (auto withClaim : {false, true})
-
3055  {
-
3056  XEnv mcEnv(*this);
-
3057  XEnv scEnv(*this, true);
-
3058 
-
3059  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3060 
-
3061  scEnv.tx(create_bridge(Account::master, jvb))
-
3062  .tx(jtx::signers(Account::master, quorum, signers))
-
3063  .close()
-
3064  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3065  .close();
-
3066 
-
3067  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3068  auto const amt = XRP(1000);
-
3069  std::uint32_t const claimID = 1;
-
3070  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3071 
-
3072  BalanceTransfer transfer(
-
3073  scEnv, Account::master, scBob, scAlice, payees, withClaim);
-
3074 
-
3075  auto tooFew = quorum - 1;
-
3076  scEnv
-
3077  .multiTx(claim_attestations(
-
3078  scAttester,
-
3079  jvb,
-
3080  mcAlice,
-
3081  amt,
-
3082  payees,
-
3083  true,
-
3084  claimID,
-
3085  dst,
-
3086  signers,
-
3087  tooFew))
-
3088  .close();
-
3089  if (withClaim)
-
3090  {
-
3091  BEAST_EXPECT(transfer.has_not_happened());
-
3092 
-
3093  // need to submit a claim transactions
-
3094  scEnv
-
3095  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3096  ter(tecXCHAIN_CLAIM_NO_QUORUM))
-
3097  .close();
-
3098  }
-
3099 
-
3100  BEAST_EXPECT(transfer.has_not_happened());
-
3101  }
-
3102 
-
3103  // Claim id of zero
-
3104  // ----------------
-
3105  for (auto withClaim : {false, true})
-
3106  {
-
3107  XEnv mcEnv(*this);
-
3108  XEnv scEnv(*this, true);
-
3109 
-
3110  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3008  BEAST_EXPECT(transfer.has_not_happened());
+
3009 
+
3010  // submit a claim transaction with the wrong account (scGw
+
3011  // instead of scAlice)
+
3012  scEnv
+
3013  .tx(xchain_claim(scGw, jvb, claimID, amt, scBob),
+
3014  ter(tecXCHAIN_BAD_CLAIM_ID))
+
3015  .close();
+
3016  BEAST_EXPECT(transfer.has_not_happened());
+
3017  }
+
3018  else
+
3019  {
+
3020  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
3021  }
+
3022  }
+
3023 
+
3024  // Claim against a claim id with no attestations
+
3025  // ---------------------------------------------
+
3026  for (auto withClaim : {false, true})
+
3027  {
+
3028  XEnv mcEnv(*this);
+
3029  XEnv scEnv(*this, true);
+
3030 
+
3031  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3032 
+
3033  scEnv.tx(create_bridge(Account::master, jvb))
+
3034  .tx(jtx::signers(Account::master, quorum, signers))
+
3035  .close()
+
3036  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3037  .close();
+
3038 
+
3039  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3040  auto const amt = XRP(1000);
+
3041  std::uint32_t const claimID = 1;
+
3042  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3043 
+
3044  BalanceTransfer transfer(
+
3045  scEnv, Account::master, scBob, scAlice, payees, withClaim);
+
3046 
+
3047  // don't send any attestations
+
3048 
+
3049  if (withClaim)
+
3050  {
+
3051  BEAST_EXPECT(transfer.has_not_happened());
+
3052 
+
3053  // need to submit a claim transactions
+
3054  scEnv
+
3055  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3056  ter(tecXCHAIN_CLAIM_NO_QUORUM))
+
3057  .close();
+
3058  }
+
3059 
+
3060  BEAST_EXPECT(transfer.has_not_happened());
+
3061  }
+
3062 
+
3063  // Claim against a claim id with attestations, but not enough to
+
3064  // make a quorum
+
3065  // --------------------------------------------------------------------
+
3066  for (auto withClaim : {false, true})
+
3067  {
+
3068  XEnv mcEnv(*this);
+
3069  XEnv scEnv(*this, true);
+
3070 
+
3071  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3072 
+
3073  scEnv.tx(create_bridge(Account::master, jvb))
+
3074  .tx(jtx::signers(Account::master, quorum, signers))
+
3075  .close()
+
3076  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3077  .close();
+
3078 
+
3079  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3080  auto const amt = XRP(1000);
+
3081  std::uint32_t const claimID = 1;
+
3082  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3083 
+
3084  BalanceTransfer transfer(
+
3085  scEnv, Account::master, scBob, scAlice, payees, withClaim);
+
3086 
+
3087  auto tooFew = quorum - 1;
+
3088  scEnv
+
3089  .multiTx(claim_attestations(
+
3090  scAttester,
+
3091  jvb,
+
3092  mcAlice,
+
3093  amt,
+
3094  payees,
+
3095  true,
+
3096  claimID,
+
3097  dst,
+
3098  signers,
+
3099  tooFew))
+
3100  .close();
+
3101  if (withClaim)
+
3102  {
+
3103  BEAST_EXPECT(transfer.has_not_happened());
+
3104 
+
3105  // need to submit a claim transactions
+
3106  scEnv
+
3107  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3108  ter(tecXCHAIN_CLAIM_NO_QUORUM))
+
3109  .close();
+
3110  }
3111 
-
3112  scEnv.tx(create_bridge(Account::master, jvb))
-
3113  .tx(jtx::signers(Account::master, quorum, signers))
-
3114  .close()
-
3115  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3116  .close();
-
3117 
-
3118  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3119  auto const amt = XRP(1000);
-
3120  std::uint32_t const claimID = 1;
-
3121  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3122 
-
3123  BalanceTransfer transfer(
-
3124  scEnv, Account::master, scBob, scAlice, payees, withClaim);
-
3125 
-
3126  scEnv
-
3127  .multiTx(
-
3128  claim_attestations(
-
3129  scAttester,
-
3130  jvb,
-
3131  mcAlice,
-
3132  amt,
-
3133  payees,
-
3134  true,
-
3135  0,
-
3136  dst,
-
3137  signers),
-
3138  ter(tecXCHAIN_NO_CLAIM_ID))
-
3139  .close();
-
3140  if (withClaim)
-
3141  {
-
3142  BEAST_EXPECT(transfer.has_not_happened());
-
3143 
-
3144  // need to submit a claim transactions
-
3145  scEnv
-
3146  .tx(xchain_claim(scAlice, jvb, 0, amt, scBob),
-
3147  ter(tecXCHAIN_NO_CLAIM_ID))
-
3148  .close();
-
3149  }
-
3150 
-
3151  BEAST_EXPECT(transfer.has_not_happened());
-
3152  }
-
3153 
-
3154  // Claim issue that does not match the expected issue on the bridge
-
3155  // (either LockingChainIssue or IssuingChainIssue, depending on the
-
3156  // chain). The claim id should already have enough attestations to
-
3157  // reach a quorum for this amount (for a different issuer).
-
3158  // ---------------------------------------------------------------------
-
3159  for (auto withClaim : {true})
-
3160  {
-
3161  XEnv mcEnv(*this);
-
3162  XEnv scEnv(*this, true);
-
3163 
-
3164  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3112  BEAST_EXPECT(transfer.has_not_happened());
+
3113  }
+
3114 
+
3115  // Claim id of zero
+
3116  // ----------------
+
3117  for (auto withClaim : {false, true})
+
3118  {
+
3119  XEnv mcEnv(*this);
+
3120  XEnv scEnv(*this, true);
+
3121 
+
3122  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3123 
+
3124  scEnv.tx(create_bridge(Account::master, jvb))
+
3125  .tx(jtx::signers(Account::master, quorum, signers))
+
3126  .close()
+
3127  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3128  .close();
+
3129 
+
3130  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3131  auto const amt = XRP(1000);
+
3132  std::uint32_t const claimID = 1;
+
3133  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3134 
+
3135  BalanceTransfer transfer(
+
3136  scEnv, Account::master, scBob, scAlice, payees, withClaim);
+
3137 
+
3138  scEnv
+
3139  .multiTx(
+
3140  claim_attestations(
+
3141  scAttester,
+
3142  jvb,
+
3143  mcAlice,
+
3144  amt,
+
3145  payees,
+
3146  true,
+
3147  0,
+
3148  dst,
+
3149  signers),
+
3150  ter(tecXCHAIN_NO_CLAIM_ID))
+
3151  .close();
+
3152  if (withClaim)
+
3153  {
+
3154  BEAST_EXPECT(transfer.has_not_happened());
+
3155 
+
3156  // need to submit a claim transactions
+
3157  scEnv
+
3158  .tx(xchain_claim(scAlice, jvb, 0, amt, scBob),
+
3159  ter(tecXCHAIN_NO_CLAIM_ID))
+
3160  .close();
+
3161  }
+
3162 
+
3163  BEAST_EXPECT(transfer.has_not_happened());
+
3164  }
3165 
-
3166  scEnv.tx(create_bridge(Account::master, jvb))
-
3167  .tx(jtx::signers(Account::master, quorum, signers))
-
3168  .close()
-
3169  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3170  .close();
-
3171 
-
3172  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3173  auto const amt = XRP(1000);
-
3174  std::uint32_t const claimID = 1;
-
3175  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3176 
-
3177  BalanceTransfer transfer(
-
3178  scEnv,
-
3179  Account::master,
-
3180  scBob,
-
3181  scAlice,
-
3182  &payees[0],
-
3183  UT_XCHAIN_DEFAULT_QUORUM,
-
3184  withClaim);
-
3185 
-
3186  scEnv
-
3187  .multiTx(claim_attestations(
-
3188  scAttester,
-
3189  jvb,
-
3190  mcAlice,
-
3191  amt,
-
3192  payees,
-
3193  true,
-
3194  claimID,
-
3195  dst,
-
3196  signers))
-
3197  .close();
-
3198 
-
3199  if (withClaim)
-
3200  {
-
3201  BEAST_EXPECT(transfer.has_not_happened());
-
3202 
-
3203  // need to submit a claim transactions
-
3204  scEnv
-
3205  .tx(xchain_claim(scAlice, jvb, claimID, scUSD(1000), scBob),
-
3206  ter(temBAD_AMOUNT))
-
3207  .close();
-
3208  }
-
3209 
-
3210  BEAST_EXPECT(transfer.has_not_happened());
-
3211  }
-
3212 
-
3213  // Claim to a destination that does not already exist on the chain
-
3214  // -----------------------------------------------------------------
-
3215  for (auto withClaim : {true})
-
3216  {
-
3217  XEnv mcEnv(*this);
-
3218  XEnv scEnv(*this, true);
-
3219 
-
3220  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3166  // Claim issue that does not match the expected issue on the bridge
+
3167  // (either LockingChainIssue or IssuingChainIssue, depending on the
+
3168  // chain). The claim id should already have enough attestations to
+
3169  // reach a quorum for this amount (for a different issuer).
+
3170  // ---------------------------------------------------------------------
+
3171  for (auto withClaim : {true})
+
3172  {
+
3173  XEnv mcEnv(*this);
+
3174  XEnv scEnv(*this, true);
+
3175 
+
3176  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3177 
+
3178  scEnv.tx(create_bridge(Account::master, jvb))
+
3179  .tx(jtx::signers(Account::master, quorum, signers))
+
3180  .close()
+
3181  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3182  .close();
+
3183 
+
3184  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3185  auto const amt = XRP(1000);
+
3186  std::uint32_t const claimID = 1;
+
3187  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3188 
+
3189  BalanceTransfer transfer(
+
3190  scEnv,
+
3191  Account::master,
+
3192  scBob,
+
3193  scAlice,
+
3194  &payees[0],
+
3195  UT_XCHAIN_DEFAULT_QUORUM,
+
3196  withClaim);
+
3197 
+
3198  scEnv
+
3199  .multiTx(claim_attestations(
+
3200  scAttester,
+
3201  jvb,
+
3202  mcAlice,
+
3203  amt,
+
3204  payees,
+
3205  true,
+
3206  claimID,
+
3207  dst,
+
3208  signers))
+
3209  .close();
+
3210 
+
3211  if (withClaim)
+
3212  {
+
3213  BEAST_EXPECT(transfer.has_not_happened());
+
3214 
+
3215  // need to submit a claim transactions
+
3216  scEnv
+
3217  .tx(xchain_claim(scAlice, jvb, claimID, scUSD(1000), scBob),
+
3218  ter(temBAD_AMOUNT))
+
3219  .close();
+
3220  }
3221 
-
3222  scEnv.tx(create_bridge(Account::master, jvb))
-
3223  .tx(jtx::signers(Account::master, quorum, signers))
-
3224  .close()
-
3225  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3226  .close();
-
3227 
-
3228  auto dst(withClaim ? std::nullopt : std::optional<Account>{scuBob});
-
3229  auto const amt = XRP(1000);
-
3230  std::uint32_t const claimID = 1;
-
3231  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3232 
-
3233  BalanceTransfer transfer(
-
3234  scEnv,
-
3235  Account::master,
-
3236  scBob,
-
3237  scAlice,
-
3238  &payees[0],
-
3239  UT_XCHAIN_DEFAULT_QUORUM,
-
3240  withClaim);
-
3241 
-
3242  scEnv
-
3243  .multiTx(claim_attestations(
-
3244  scAttester,
-
3245  jvb,
-
3246  mcAlice,
-
3247  amt,
-
3248  payees,
-
3249  true,
-
3250  claimID,
-
3251  dst,
-
3252  signers))
-
3253  .close();
-
3254  if (withClaim)
-
3255  {
-
3256  BEAST_EXPECT(transfer.has_not_happened());
-
3257 
-
3258  // need to submit a claim transactions
-
3259  scEnv
-
3260  .tx(xchain_claim(scAlice, jvb, claimID, amt, scuBob),
-
3261  ter(tecNO_DST))
-
3262  .close();
-
3263  }
-
3264 
-
3265  BEAST_EXPECT(transfer.has_not_happened());
-
3266  }
-
3267 
-
3268  // Claim where the claim id owner does not have enough XRP to pay
-
3269  // the reward
-
3270  // ------------------------------------------------------------------
-
3271  for (auto withClaim : {false, true})
-
3272  {
-
3273  XEnv mcEnv(*this);
-
3274  XEnv scEnv(*this, true);
-
3275 
-
3276  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3277  STAmount huge_reward{XRP(20000)};
-
3278  BEAST_EXPECT(huge_reward > scEnv.balance(scAlice));
+
3222  BEAST_EXPECT(transfer.has_not_happened());
+
3223  }
+
3224 
+
3225  // Claim to a destination that does not already exist on the chain
+
3226  // -----------------------------------------------------------------
+
3227  for (auto withClaim : {true})
+
3228  {
+
3229  XEnv mcEnv(*this);
+
3230  XEnv scEnv(*this, true);
+
3231 
+
3232  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3233 
+
3234  scEnv.tx(create_bridge(Account::master, jvb))
+
3235  .tx(jtx::signers(Account::master, quorum, signers))
+
3236  .close()
+
3237  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3238  .close();
+
3239 
+
3240  auto dst(withClaim ? std::nullopt : std::optional<Account>{scuBob});
+
3241  auto const amt = XRP(1000);
+
3242  std::uint32_t const claimID = 1;
+
3243  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3244 
+
3245  BalanceTransfer transfer(
+
3246  scEnv,
+
3247  Account::master,
+
3248  scBob,
+
3249  scAlice,
+
3250  &payees[0],
+
3251  UT_XCHAIN_DEFAULT_QUORUM,
+
3252  withClaim);
+
3253 
+
3254  scEnv
+
3255  .multiTx(claim_attestations(
+
3256  scAttester,
+
3257  jvb,
+
3258  mcAlice,
+
3259  amt,
+
3260  payees,
+
3261  true,
+
3262  claimID,
+
3263  dst,
+
3264  signers))
+
3265  .close();
+
3266  if (withClaim)
+
3267  {
+
3268  BEAST_EXPECT(transfer.has_not_happened());
+
3269 
+
3270  // need to submit a claim transactions
+
3271  scEnv
+
3272  .tx(xchain_claim(scAlice, jvb, claimID, amt, scuBob),
+
3273  ter(tecNO_DST))
+
3274  .close();
+
3275  }
+
3276 
+
3277  BEAST_EXPECT(transfer.has_not_happened());
+
3278  }
3279 
-
3280  scEnv.tx(create_bridge(Account::master, jvb, huge_reward))
-
3281  .tx(jtx::signers(Account::master, quorum, signers))
-
3282  .close()
-
3283  .tx(xchain_create_claim_id(scAlice, jvb, huge_reward, mcAlice))
-
3284  .close();
-
3285 
-
3286  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3287  auto const amt = XRP(1000);
-
3288  std::uint32_t const claimID = 1;
-
3289  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3290 
-
3291  BalanceTransfer transfer(
-
3292  scEnv,
-
3293  Account::master,
-
3294  scBob,
-
3295  scAlice,
-
3296  &payees[0],
-
3297  UT_XCHAIN_DEFAULT_QUORUM,
-
3298  withClaim);
-
3299 
-
3300  if (withClaim)
-
3301  {
-
3302  scEnv
-
3303  .multiTx(claim_attestations(
-
3304  scAttester,
-
3305  jvb,
-
3306  mcAlice,
-
3307  amt,
-
3308  payees,
-
3309  true,
-
3310  claimID,
-
3311  dst,
-
3312  signers))
-
3313  .close();
-
3314  BEAST_EXPECT(transfer.has_not_happened());
-
3315 
-
3316  // need to submit a claim transactions
-
3317  scEnv
-
3318  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3319  ter(tecUNFUNDED_PAYMENT))
-
3320  .close();
-
3321  }
-
3322  else
-
3323  {
-
3324  auto txns = claim_attestations(
-
3325  scAttester,
-
3326  jvb,
-
3327  mcAlice,
-
3328  amt,
-
3329  payees,
-
3330  true,
-
3331  claimID,
-
3332  dst,
-
3333  signers);
-
3334  for (int i = 0; i < UT_XCHAIN_DEFAULT_QUORUM - 1; ++i)
-
3335  {
-
3336  scEnv.tx(txns[i]).close();
-
3337  }
-
3338  scEnv.tx(txns.back());
-
3339  scEnv.close();
-
3340  // The attestation should succeed, because it adds an
-
3341  // attestation, but the claim should fail with insufficient
-
3342  // funds
-
3343  scEnv
-
3344  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3345  ter(tecUNFUNDED_PAYMENT))
-
3346  .close();
-
3347  }
-
3348 
-
3349  BEAST_EXPECT(transfer.has_not_happened());
-
3350  }
-
3351 
-
3352  // Claim where the claim id owner has enough XRP to pay the reward,
-
3353  // but it would put his balance below the reserve
-
3354  // --------------------------------------------------------------------
-
3355  for (auto withClaim : {false, true})
-
3356  {
-
3357  XEnv mcEnv(*this);
-
3358  XEnv scEnv(*this, true);
-
3359 
-
3360  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3361 
-
3362  scEnv.tx(create_bridge(Account::master, jvb))
-
3363  .tx(jtx::signers(Account::master, quorum, signers))
-
3364  .fund(
-
3365  res0 + reward,
-
3366  scuAlice) // just not enough because of fees
-
3367  .close()
-
3368  .tx(xchain_create_claim_id(scuAlice, jvb, reward, mcAlice),
-
3369  ter(tecINSUFFICIENT_RESERVE))
-
3370  .close();
+
3280  // Claim where the claim id owner does not have enough XRP to pay
+
3281  // the reward
+
3282  // ------------------------------------------------------------------
+
3283  for (auto withClaim : {false, true})
+
3284  {
+
3285  XEnv mcEnv(*this);
+
3286  XEnv scEnv(*this, true);
+
3287 
+
3288  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3289  STAmount huge_reward{XRP(20000)};
+
3290  BEAST_EXPECT(huge_reward > scEnv.balance(scAlice));
+
3291 
+
3292  scEnv.tx(create_bridge(Account::master, jvb, huge_reward))
+
3293  .tx(jtx::signers(Account::master, quorum, signers))
+
3294  .close()
+
3295  .tx(xchain_create_claim_id(scAlice, jvb, huge_reward, mcAlice))
+
3296  .close();
+
3297 
+
3298  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3299  auto const amt = XRP(1000);
+
3300  std::uint32_t const claimID = 1;
+
3301  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3302 
+
3303  BalanceTransfer transfer(
+
3304  scEnv,
+
3305  Account::master,
+
3306  scBob,
+
3307  scAlice,
+
3308  &payees[0],
+
3309  UT_XCHAIN_DEFAULT_QUORUM,
+
3310  withClaim);
+
3311 
+
3312  if (withClaim)
+
3313  {
+
3314  scEnv
+
3315  .multiTx(claim_attestations(
+
3316  scAttester,
+
3317  jvb,
+
3318  mcAlice,
+
3319  amt,
+
3320  payees,
+
3321  true,
+
3322  claimID,
+
3323  dst,
+
3324  signers))
+
3325  .close();
+
3326  BEAST_EXPECT(transfer.has_not_happened());
+
3327 
+
3328  // need to submit a claim transactions
+
3329  scEnv
+
3330  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3331  ter(tecUNFUNDED_PAYMENT))
+
3332  .close();
+
3333  }
+
3334  else
+
3335  {
+
3336  auto txns = claim_attestations(
+
3337  scAttester,
+
3338  jvb,
+
3339  mcAlice,
+
3340  amt,
+
3341  payees,
+
3342  true,
+
3343  claimID,
+
3344  dst,
+
3345  signers);
+
3346  for (int i = 0; i < UT_XCHAIN_DEFAULT_QUORUM - 1; ++i)
+
3347  {
+
3348  scEnv.tx(txns[i]).close();
+
3349  }
+
3350  scEnv.tx(txns.back());
+
3351  scEnv.close();
+
3352  // The attestation should succeed, because it adds an
+
3353  // attestation, but the claim should fail with insufficient
+
3354  // funds
+
3355  scEnv
+
3356  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3357  ter(tecUNFUNDED_PAYMENT))
+
3358  .close();
+
3359  }
+
3360 
+
3361  BEAST_EXPECT(transfer.has_not_happened());
+
3362  }
+
3363 
+
3364  // Claim where the claim id owner has enough XRP to pay the reward,
+
3365  // but it would put his balance below the reserve
+
3366  // --------------------------------------------------------------------
+
3367  for (auto withClaim : {false, true})
+
3368  {
+
3369  XEnv mcEnv(*this);
+
3370  XEnv scEnv(*this, true);
3371 
-
3372  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3373  auto const amt = XRP(1000);
-
3374  std::uint32_t const claimID = 1;
-
3375  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3376 
-
3377  BalanceTransfer transfer(
-
3378  scEnv, Account::master, scBob, scuAlice, payees, withClaim);
-
3379 
-
3380  scEnv
-
3381  .tx(claim_attestation(
-
3382  scAttester,
-
3383  jvb,
-
3384  mcAlice,
-
3385  amt,
-
3386  payees[0],
-
3387  true,
-
3388  claimID,
-
3389  dst,
-
3390  signers[0]),
-
3391  ter(tecXCHAIN_NO_CLAIM_ID))
-
3392  .close();
-
3393  if (withClaim)
-
3394  {
-
3395  BEAST_EXPECT(transfer.has_not_happened());
-
3396 
-
3397  // need to submit a claim transactions
-
3398  scEnv
-
3399  .tx(xchain_claim(scuAlice, jvb, claimID, amt, scBob),
-
3400  ter(tecXCHAIN_NO_CLAIM_ID))
-
3401  .close();
-
3402  }
-
3403 
-
3404  BEAST_EXPECT(transfer.has_not_happened());
-
3405  }
-
3406 
-
3407  // Pay to an account with deposit auth set
-
3408  // ---------------------------------------
-
3409  for (auto withClaim : {false, true})
-
3410  {
-
3411  XEnv mcEnv(*this);
-
3412  XEnv scEnv(*this, true);
-
3413 
-
3414  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3372  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3373 
+
3374  scEnv.tx(create_bridge(Account::master, jvb))
+
3375  .tx(jtx::signers(Account::master, quorum, signers))
+
3376  .fund(
+
3377  res0 + reward,
+
3378  scuAlice) // just not enough because of fees
+
3379  .close()
+
3380  .tx(xchain_create_claim_id(scuAlice, jvb, reward, mcAlice),
+
3381  ter(tecINSUFFICIENT_RESERVE))
+
3382  .close();
+
3383 
+
3384  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3385  auto const amt = XRP(1000);
+
3386  std::uint32_t const claimID = 1;
+
3387  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3388 
+
3389  BalanceTransfer transfer(
+
3390  scEnv, Account::master, scBob, scuAlice, payees, withClaim);
+
3391 
+
3392  scEnv
+
3393  .tx(claim_attestation(
+
3394  scAttester,
+
3395  jvb,
+
3396  mcAlice,
+
3397  amt,
+
3398  payees[0],
+
3399  true,
+
3400  claimID,
+
3401  dst,
+
3402  signers[0]),
+
3403  ter(tecXCHAIN_NO_CLAIM_ID))
+
3404  .close();
+
3405  if (withClaim)
+
3406  {
+
3407  BEAST_EXPECT(transfer.has_not_happened());
+
3408 
+
3409  // need to submit a claim transactions
+
3410  scEnv
+
3411  .tx(xchain_claim(scuAlice, jvb, claimID, amt, scBob),
+
3412  ter(tecXCHAIN_NO_CLAIM_ID))
+
3413  .close();
+
3414  }
3415 
-
3416  scEnv.tx(create_bridge(Account::master, jvb))
-
3417  .tx(jtx::signers(Account::master, quorum, signers))
-
3418  .tx(fset("scBob", asfDepositAuth)) // set deposit auth
-
3419  .close()
-
3420  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3421  .close();
-
3422 
-
3423  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3424  auto const amt = XRP(1000);
-
3425  std::uint32_t const claimID = 1;
-
3426  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3416  BEAST_EXPECT(transfer.has_not_happened());
+
3417  }
+
3418 
+
3419  // Pay to an account with deposit auth set
+
3420  // ---------------------------------------
+
3421  for (auto withClaim : {false, true})
+
3422  {
+
3423  XEnv mcEnv(*this);
+
3424  XEnv scEnv(*this, true);
+
3425 
+
3426  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
3427 
-
3428  BalanceTransfer transfer(
-
3429  scEnv,
-
3430  Account::master,
-
3431  scBob,
-
3432  scAlice,
-
3433  &payees[0],
-
3434  UT_XCHAIN_DEFAULT_QUORUM,
-
3435  withClaim);
-
3436  auto txns = claim_attestations(
-
3437  scAttester,
-
3438  jvb,
-
3439  mcAlice,
-
3440  amt,
-
3441  payees,
-
3442  true,
-
3443  claimID,
-
3444  dst,
-
3445  signers);
-
3446  for (int i = 0; i < UT_XCHAIN_DEFAULT_QUORUM - 1; ++i)
-
3447  {
-
3448  scEnv.tx(txns[i]).close();
-
3449  }
-
3450  if (withClaim)
-
3451  {
-
3452  scEnv.tx(txns.back()).close();
-
3453 
-
3454  BEAST_EXPECT(transfer.has_not_happened());
-
3455 
-
3456  // need to submit a claim transactions
-
3457  scEnv
-
3458  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3459  ter(tecNO_PERMISSION))
-
3460  .close();
-
3461 
-
3462  // the transfer failed, but check that we can still use the
-
3463  // claimID with a different account
-
3464  Balance scCarol_bal(scEnv, scCarol);
+
3428  scEnv.tx(create_bridge(Account::master, jvb))
+
3429  .tx(jtx::signers(Account::master, quorum, signers))
+
3430  .tx(fset("scBob", asfDepositAuth)) // set deposit auth
+
3431  .close()
+
3432  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3433  .close();
+
3434 
+
3435  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3436  auto const amt = XRP(1000);
+
3437  std::uint32_t const claimID = 1;
+
3438  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3439 
+
3440  BalanceTransfer transfer(
+
3441  scEnv,
+
3442  Account::master,
+
3443  scBob,
+
3444  scAlice,
+
3445  &payees[0],
+
3446  UT_XCHAIN_DEFAULT_QUORUM,
+
3447  withClaim);
+
3448  auto txns = claim_attestations(
+
3449  scAttester,
+
3450  jvb,
+
3451  mcAlice,
+
3452  amt,
+
3453  payees,
+
3454  true,
+
3455  claimID,
+
3456  dst,
+
3457  signers);
+
3458  for (int i = 0; i < UT_XCHAIN_DEFAULT_QUORUM - 1; ++i)
+
3459  {
+
3460  scEnv.tx(txns[i]).close();
+
3461  }
+
3462  if (withClaim)
+
3463  {
+
3464  scEnv.tx(txns.back()).close();
3465 
-
3466  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol))
-
3467  .close();
-
3468  BEAST_EXPECT(scCarol_bal.diff() == amt);
-
3469  }
-
3470  else
-
3471  {
-
3472  scEnv.tx(txns.back()).close();
-
3473  scEnv
-
3474  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3475  ter(tecNO_PERMISSION))
-
3476  .close();
-
3477  // A way would be to remove deposit auth and resubmit the
-
3478  // attestations (even though the witness servers won't do
-
3479  // it)
-
3480  scEnv
-
3481  .tx(fset("scBob", 0, asfDepositAuth)) // clear deposit auth
-
3482  .close();
-
3483 
-
3484  Balance scBob_bal(scEnv, scBob);
-
3485  scEnv.tx(txns.back()).close();
-
3486  BEAST_EXPECT(scBob_bal.diff() == amt);
-
3487  }
-
3488  }
-
3489 
-
3490  // Pay to an account with Destination Tag set
-
3491  // ------------------------------------------
-
3492  for (auto withClaim : {false, true})
-
3493  {
-
3494  XEnv mcEnv(*this);
-
3495  XEnv scEnv(*this, true);
-
3496 
-
3497  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3498 
-
3499  scEnv.tx(create_bridge(Account::master, jvb))
-
3500  .tx(jtx::signers(Account::master, quorum, signers))
-
3501  .tx(fset("scBob", asfRequireDest)) // set dest tag
-
3502  .close()
-
3503  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3504  .close();
-
3505 
-
3506  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3507  auto const amt = XRP(1000);
-
3508  std::uint32_t const claimID = 1;
-
3509  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3466  BEAST_EXPECT(transfer.has_not_happened());
+
3467 
+
3468  // need to submit a claim transactions
+
3469  scEnv
+
3470  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3471  ter(tecNO_PERMISSION))
+
3472  .close();
+
3473 
+
3474  // the transfer failed, but check that we can still use the
+
3475  // claimID with a different account
+
3476  Balance scCarol_bal(scEnv, scCarol);
+
3477 
+
3478  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol))
+
3479  .close();
+
3480  BEAST_EXPECT(scCarol_bal.diff() == amt);
+
3481  }
+
3482  else
+
3483  {
+
3484  scEnv.tx(txns.back()).close();
+
3485  scEnv
+
3486  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3487  ter(tecNO_PERMISSION))
+
3488  .close();
+
3489  // A way would be to remove deposit auth and resubmit the
+
3490  // attestations (even though the witness servers won't do
+
3491  // it)
+
3492  scEnv
+
3493  .tx(fset("scBob", 0, asfDepositAuth)) // clear deposit auth
+
3494  .close();
+
3495 
+
3496  Balance scBob_bal(scEnv, scBob);
+
3497  scEnv.tx(txns.back()).close();
+
3498  BEAST_EXPECT(scBob_bal.diff() == amt);
+
3499  }
+
3500  }
+
3501 
+
3502  // Pay to an account with Destination Tag set
+
3503  // ------------------------------------------
+
3504  for (auto withClaim : {false, true})
+
3505  {
+
3506  XEnv mcEnv(*this);
+
3507  XEnv scEnv(*this, true);
+
3508 
+
3509  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
3510 
-
3511  BalanceTransfer transfer(
-
3512  scEnv,
-
3513  Account::master,
-
3514  scBob,
-
3515  scAlice,
-
3516  &payees[0],
-
3517  UT_XCHAIN_DEFAULT_QUORUM,
-
3518  withClaim);
-
3519  auto txns = claim_attestations(
-
3520  scAttester,
-
3521  jvb,
-
3522  mcAlice,
-
3523  amt,
-
3524  payees,
-
3525  true,
-
3526  claimID,
-
3527  dst,
-
3528  signers);
-
3529  for (int i = 0; i < UT_XCHAIN_DEFAULT_QUORUM - 1; ++i)
-
3530  {
-
3531  scEnv.tx(txns[i]).close();
-
3532  }
-
3533  if (withClaim)
-
3534  {
-
3535  scEnv.tx(txns.back()).close();
-
3536  BEAST_EXPECT(transfer.has_not_happened());
-
3537 
-
3538  // need to submit a claim transactions
-
3539  scEnv
-
3540  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3541  ter(tecDST_TAG_NEEDED))
-
3542  .close();
-
3543 
-
3544  // the transfer failed, but check that we can still use the
-
3545  // claimID with a different account
-
3546  Balance scCarol_bal(scEnv, scCarol);
-
3547 
-
3548  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol))
-
3549  .close();
-
3550  BEAST_EXPECT(scCarol_bal.diff() == amt);
-
3551  }
-
3552  else
-
3553  {
-
3554  scEnv.tx(txns.back()).close();
-
3555  scEnv
-
3556  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
-
3557  ter(tecDST_TAG_NEEDED))
-
3558  .close();
-
3559  // A way would be to remove the destination tag requirement
-
3560  // and resubmit the attestations (even though the witness
-
3561  // servers won't do it)
-
3562  scEnv
-
3563  .tx(fset("scBob", 0, asfRequireDest)) // clear dest tag
-
3564  .close();
-
3565 
-
3566  Balance scBob_bal(scEnv, scBob);
-
3567 
-
3568  scEnv.tx(txns.back()).close();
-
3569  BEAST_EXPECT(scBob_bal.diff() == amt);
-
3570  }
-
3571  }
-
3572 
-
3573  // Pay to an account with deposit auth set. Check that the attestations
-
3574  // are still validated and that we can used the claimID to transfer the
-
3575  // funds to a different account (which doesn't have deposit auth set)
-
3576  // --------------------------------------------------------------------
-
3577  {
-
3578  XEnv mcEnv(*this);
-
3579  XEnv scEnv(*this, true);
-
3580 
-
3581  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3582 
-
3583  scEnv.tx(create_bridge(Account::master, jvb))
-
3584  .tx(jtx::signers(Account::master, quorum, signers))
-
3585  .tx(fset("scBob", asfDepositAuth)) // set deposit auth
-
3586  .close()
-
3587  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3588  .close();
-
3589 
-
3590  auto dst(std::optional<Account>{scBob});
-
3591  auto const amt = XRP(1000);
-
3592  std::uint32_t const claimID = 1;
-
3593  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3511  scEnv.tx(create_bridge(Account::master, jvb))
+
3512  .tx(jtx::signers(Account::master, quorum, signers))
+
3513  .tx(fset("scBob", asfRequireDest)) // set dest tag
+
3514  .close()
+
3515  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3516  .close();
+
3517 
+
3518  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3519  auto const amt = XRP(1000);
+
3520  std::uint32_t const claimID = 1;
+
3521  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3522 
+
3523  BalanceTransfer transfer(
+
3524  scEnv,
+
3525  Account::master,
+
3526  scBob,
+
3527  scAlice,
+
3528  &payees[0],
+
3529  UT_XCHAIN_DEFAULT_QUORUM,
+
3530  withClaim);
+
3531  auto txns = claim_attestations(
+
3532  scAttester,
+
3533  jvb,
+
3534  mcAlice,
+
3535  amt,
+
3536  payees,
+
3537  true,
+
3538  claimID,
+
3539  dst,
+
3540  signers);
+
3541  for (int i = 0; i < UT_XCHAIN_DEFAULT_QUORUM - 1; ++i)
+
3542  {
+
3543  scEnv.tx(txns[i]).close();
+
3544  }
+
3545  if (withClaim)
+
3546  {
+
3547  scEnv.tx(txns.back()).close();
+
3548  BEAST_EXPECT(transfer.has_not_happened());
+
3549 
+
3550  // need to submit a claim transactions
+
3551  scEnv
+
3552  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3553  ter(tecDST_TAG_NEEDED))
+
3554  .close();
+
3555 
+
3556  // the transfer failed, but check that we can still use the
+
3557  // claimID with a different account
+
3558  Balance scCarol_bal(scEnv, scCarol);
+
3559 
+
3560  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol))
+
3561  .close();
+
3562  BEAST_EXPECT(scCarol_bal.diff() == amt);
+
3563  }
+
3564  else
+
3565  {
+
3566  scEnv.tx(txns.back()).close();
+
3567  scEnv
+
3568  .tx(xchain_claim(scAlice, jvb, claimID, amt, scBob),
+
3569  ter(tecDST_TAG_NEEDED))
+
3570  .close();
+
3571  // A way would be to remove the destination tag requirement
+
3572  // and resubmit the attestations (even though the witness
+
3573  // servers won't do it)
+
3574  scEnv
+
3575  .tx(fset("scBob", 0, asfRequireDest)) // clear dest tag
+
3576  .close();
+
3577 
+
3578  Balance scBob_bal(scEnv, scBob);
+
3579 
+
3580  scEnv.tx(txns.back()).close();
+
3581  BEAST_EXPECT(scBob_bal.diff() == amt);
+
3582  }
+
3583  }
+
3584 
+
3585  // Pay to an account with deposit auth set. Check that the attestations
+
3586  // are still validated and that we can used the claimID to transfer the
+
3587  // funds to a different account (which doesn't have deposit auth set)
+
3588  // --------------------------------------------------------------------
+
3589  {
+
3590  XEnv mcEnv(*this);
+
3591  XEnv scEnv(*this, true);
+
3592 
+
3593  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
3594 
-
3595  // we should be able to submit the attestations, but the transfer
-
3596  // should not occur because dest account has deposit auth set
-
3597  Balance scBob_bal(scEnv, scBob);
-
3598 
-
3599  scEnv.multiTx(claim_attestations(
-
3600  scAttester,
-
3601  jvb,
-
3602  mcAlice,
-
3603  amt,
-
3604  payees,
-
3605  true,
-
3606  claimID,
-
3607  dst,
-
3608  signers));
-
3609  BEAST_EXPECT(scBob_bal.diff() == STAmount(0));
+
3595  scEnv.tx(create_bridge(Account::master, jvb))
+
3596  .tx(jtx::signers(Account::master, quorum, signers))
+
3597  .tx(fset("scBob", asfDepositAuth)) // set deposit auth
+
3598  .close()
+
3599  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3600  .close();
+
3601 
+
3602  auto dst(std::optional<Account>{scBob});
+
3603  auto const amt = XRP(1000);
+
3604  std::uint32_t const claimID = 1;
+
3605  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3606 
+
3607  // we should be able to submit the attestations, but the transfer
+
3608  // should not occur because dest account has deposit auth set
+
3609  Balance scBob_bal(scEnv, scBob);
3610 
-
3611  // Check that check that we still can use the claimID to transfer
-
3612  // the amount to a different account
-
3613  Balance scCarol_bal(scEnv, scCarol);
-
3614 
-
3615  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol)).close();
-
3616  BEAST_EXPECT(scCarol_bal.diff() == amt);
-
3617  }
-
3618 
-
3619  // Claim where the amount different from what is attested to
-
3620  // ---------------------------------------------------------
-
3621  for (auto withClaim : {true})
-
3622  {
-
3623  XEnv mcEnv(*this);
-
3624  XEnv scEnv(*this, true);
-
3625 
-
3626  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3627 
-
3628  scEnv.tx(create_bridge(Account::master, jvb))
-
3629  .tx(jtx::signers(Account::master, quorum, signers))
-
3630  .close()
-
3631  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3632  .close();
-
3633 
-
3634  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3635  auto const amt = XRP(1000);
-
3636  std::uint32_t const claimID = 1;
-
3637  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3638 
-
3639  BalanceTransfer transfer(
-
3640  scEnv,
-
3641  Account::master,
-
3642  scBob,
-
3643  scAlice,
-
3644  &payees[0],
-
3645  UT_XCHAIN_DEFAULT_QUORUM,
-
3646  withClaim);
-
3647  scEnv.multiTx(claim_attestations(
-
3648  scAttester,
-
3649  jvb,
-
3650  mcAlice,
-
3651  amt,
-
3652  payees,
-
3653  true,
-
3654  claimID,
-
3655  dst,
-
3656  signers));
-
3657  if (withClaim)
-
3658  {
-
3659  BEAST_EXPECT(transfer.has_not_happened());
-
3660 
-
3661  // claim wrong amount
-
3662  scEnv
-
3663  .tx(xchain_claim(scAlice, jvb, claimID, one_xrp, scBob),
-
3664  ter(tecXCHAIN_CLAIM_NO_QUORUM))
-
3665  .close();
-
3666  }
-
3667 
-
3668  BEAST_EXPECT(transfer.has_not_happened());
-
3669  }
-
3670 
-
3671  // Verify that rewards are paid from the account that owns the claim
-
3672  // id
-
3673  // --------------------------------------------------------------------
-
3674  for (auto withClaim : {false, true})
-
3675  {
-
3676  XEnv mcEnv(*this);
-
3677  XEnv scEnv(*this, true);
-
3678 
-
3679  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3680 
-
3681  scEnv.tx(create_bridge(Account::master, jvb))
-
3682  .tx(jtx::signers(Account::master, quorum, signers))
-
3683  .close()
-
3684  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3685  .close();
-
3686 
-
3687  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3688  auto const amt = XRP(1000);
-
3689  std::uint32_t const claimID = 1;
-
3690  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3691 
-
3692  BalanceTransfer transfer(
-
3693  scEnv,
-
3694  Account::master,
-
3695  scBob,
-
3696  scAlice,
-
3697  &payees[0],
-
3698  UT_XCHAIN_DEFAULT_QUORUM,
-
3699  withClaim);
-
3700  Balance scAlice_bal(scEnv, scAlice);
-
3701  scEnv.multiTx(claim_attestations(
-
3702  scAttester,
-
3703  jvb,
-
3704  mcAlice,
-
3705  amt,
-
3706  payees,
-
3707  true,
-
3708  claimID,
-
3709  dst,
-
3710  signers));
-
3711 
-
3712  STAmount claim_cost = reward;
-
3713 
-
3714  if (withClaim)
-
3715  {
-
3716  BEAST_EXPECT(transfer.has_not_happened());
-
3717 
-
3718  // need to submit a claim transactions
-
3719  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
3720  .close();
-
3721  claim_cost += tx_fee;
-
3722  }
+
3611  scEnv.multiTx(claim_attestations(
+
3612  scAttester,
+
3613  jvb,
+
3614  mcAlice,
+
3615  amt,
+
3616  payees,
+
3617  true,
+
3618  claimID,
+
3619  dst,
+
3620  signers));
+
3621  BEAST_EXPECT(scBob_bal.diff() == STAmount(0));
+
3622 
+
3623  // Check that check that we still can use the claimID to transfer
+
3624  // the amount to a different account
+
3625  Balance scCarol_bal(scEnv, scCarol);
+
3626 
+
3627  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol)).close();
+
3628  BEAST_EXPECT(scCarol_bal.diff() == amt);
+
3629  }
+
3630 
+
3631  // Claim where the amount different from what is attested to
+
3632  // ---------------------------------------------------------
+
3633  for (auto withClaim : {true})
+
3634  {
+
3635  XEnv mcEnv(*this);
+
3636  XEnv scEnv(*this, true);
+
3637 
+
3638  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3639 
+
3640  scEnv.tx(create_bridge(Account::master, jvb))
+
3641  .tx(jtx::signers(Account::master, quorum, signers))
+
3642  .close()
+
3643  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3644  .close();
+
3645 
+
3646  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3647  auto const amt = XRP(1000);
+
3648  std::uint32_t const claimID = 1;
+
3649  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3650 
+
3651  BalanceTransfer transfer(
+
3652  scEnv,
+
3653  Account::master,
+
3654  scBob,
+
3655  scAlice,
+
3656  &payees[0],
+
3657  UT_XCHAIN_DEFAULT_QUORUM,
+
3658  withClaim);
+
3659  scEnv.multiTx(claim_attestations(
+
3660  scAttester,
+
3661  jvb,
+
3662  mcAlice,
+
3663  amt,
+
3664  payees,
+
3665  true,
+
3666  claimID,
+
3667  dst,
+
3668  signers));
+
3669  if (withClaim)
+
3670  {
+
3671  BEAST_EXPECT(transfer.has_not_happened());
+
3672 
+
3673  // claim wrong amount
+
3674  scEnv
+
3675  .tx(xchain_claim(scAlice, jvb, claimID, one_xrp, scBob),
+
3676  ter(tecXCHAIN_CLAIM_NO_QUORUM))
+
3677  .close();
+
3678  }
+
3679 
+
3680  BEAST_EXPECT(transfer.has_not_happened());
+
3681  }
+
3682 
+
3683  // Verify that rewards are paid from the account that owns the claim
+
3684  // id
+
3685  // --------------------------------------------------------------------
+
3686  for (auto withClaim : {false, true})
+
3687  {
+
3688  XEnv mcEnv(*this);
+
3689  XEnv scEnv(*this, true);
+
3690 
+
3691  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3692 
+
3693  scEnv.tx(create_bridge(Account::master, jvb))
+
3694  .tx(jtx::signers(Account::master, quorum, signers))
+
3695  .close()
+
3696  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3697  .close();
+
3698 
+
3699  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3700  auto const amt = XRP(1000);
+
3701  std::uint32_t const claimID = 1;
+
3702  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3703 
+
3704  BalanceTransfer transfer(
+
3705  scEnv,
+
3706  Account::master,
+
3707  scBob,
+
3708  scAlice,
+
3709  &payees[0],
+
3710  UT_XCHAIN_DEFAULT_QUORUM,
+
3711  withClaim);
+
3712  Balance scAlice_bal(scEnv, scAlice);
+
3713  scEnv.multiTx(claim_attestations(
+
3714  scAttester,
+
3715  jvb,
+
3716  mcAlice,
+
3717  amt,
+
3718  payees,
+
3719  true,
+
3720  claimID,
+
3721  dst,
+
3722  signers));
3723 
-
3724  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
3725  BEAST_EXPECT(
-
3726  scAlice_bal.diff() == -claim_cost); // because reward % 4 == 0
-
3727  }
-
3728 
-
3729  // Verify that if a reward is not evenly divisible among the reward
-
3730  // accounts, the remaining amount goes to the claim id owner.
-
3731  // ----------------------------------------------------------------
-
3732  for (auto withClaim : {false, true})
-
3733  {
-
3734  XEnv mcEnv(*this);
-
3735  XEnv scEnv(*this, true);
-
3736 
-
3737  mcEnv.tx(create_bridge(mcDoor, jvb, tiny_reward)).close();
-
3738 
-
3739  scEnv.tx(create_bridge(Account::master, jvb, tiny_reward))
-
3740  .tx(jtx::signers(Account::master, quorum, signers))
-
3741  .close()
-
3742  .tx(xchain_create_claim_id(scAlice, jvb, tiny_reward, mcAlice))
-
3743  .close();
-
3744 
-
3745  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3746  auto const amt = XRP(1000);
-
3747  std::uint32_t const claimID = 1;
-
3748  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3749 
-
3750  BalanceTransfer transfer(
-
3751  scEnv,
-
3752  Account::master,
-
3753  scBob,
-
3754  scAlice,
-
3755  &payees[0],
-
3756  UT_XCHAIN_DEFAULT_QUORUM,
-
3757  withClaim);
-
3758  Balance scAlice_bal(scEnv, scAlice);
-
3759  scEnv.multiTx(claim_attestations(
-
3760  scAttester,
-
3761  jvb,
-
3762  mcAlice,
-
3763  amt,
-
3764  payees,
-
3765  true,
-
3766  claimID,
-
3767  dst,
-
3768  signers));
-
3769  STAmount claim_cost = tiny_reward;
-
3770 
-
3771  if (withClaim)
-
3772  {
-
3773  BEAST_EXPECT(transfer.has_not_happened());
-
3774 
-
3775  // need to submit a claim transactions
-
3776  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
3777  .close();
-
3778  claim_cost += tx_fee;
-
3779  }
-
3780 
-
3781  BEAST_EXPECT(transfer.has_happened(amt, tiny_reward_split));
-
3782  BEAST_EXPECT(
-
3783  scAlice_bal.diff() == -(claim_cost - tiny_reward_remainder));
-
3784  }
-
3785 
-
3786  // If a reward distribution fails for one of the reward accounts
-
3787  // (the reward account doesn't exist or has deposit auth set), then
-
3788  // the txn should still succeed, but that portion should go to the
-
3789  // claim id owner.
-
3790  // -------------------------------------------------------------------
-
3791  for (auto withClaim : {false, true})
-
3792  {
-
3793  XEnv mcEnv(*this);
-
3794  XEnv scEnv(*this, true);
-
3795 
-
3796  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3724  STAmount claim_cost = reward;
+
3725 
+
3726  if (withClaim)
+
3727  {
+
3728  BEAST_EXPECT(transfer.has_not_happened());
+
3729 
+
3730  // need to submit a claim transactions
+
3731  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
3732  .close();
+
3733  claim_cost += tx_fee;
+
3734  }
+
3735 
+
3736  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
3737  BEAST_EXPECT(
+
3738  scAlice_bal.diff() == -claim_cost); // because reward % 4 == 0
+
3739  }
+
3740 
+
3741  // Verify that if a reward is not evenly divisible among the reward
+
3742  // accounts, the remaining amount goes to the claim id owner.
+
3743  // ----------------------------------------------------------------
+
3744  for (auto withClaim : {false, true})
+
3745  {
+
3746  XEnv mcEnv(*this);
+
3747  XEnv scEnv(*this, true);
+
3748 
+
3749  mcEnv.tx(create_bridge(mcDoor, jvb, tiny_reward)).close();
+
3750 
+
3751  scEnv.tx(create_bridge(Account::master, jvb, tiny_reward))
+
3752  .tx(jtx::signers(Account::master, quorum, signers))
+
3753  .close()
+
3754  .tx(xchain_create_claim_id(scAlice, jvb, tiny_reward, mcAlice))
+
3755  .close();
+
3756 
+
3757  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3758  auto const amt = XRP(1000);
+
3759  std::uint32_t const claimID = 1;
+
3760  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3761 
+
3762  BalanceTransfer transfer(
+
3763  scEnv,
+
3764  Account::master,
+
3765  scBob,
+
3766  scAlice,
+
3767  &payees[0],
+
3768  UT_XCHAIN_DEFAULT_QUORUM,
+
3769  withClaim);
+
3770  Balance scAlice_bal(scEnv, scAlice);
+
3771  scEnv.multiTx(claim_attestations(
+
3772  scAttester,
+
3773  jvb,
+
3774  mcAlice,
+
3775  amt,
+
3776  payees,
+
3777  true,
+
3778  claimID,
+
3779  dst,
+
3780  signers));
+
3781  STAmount claim_cost = tiny_reward;
+
3782 
+
3783  if (withClaim)
+
3784  {
+
3785  BEAST_EXPECT(transfer.has_not_happened());
+
3786 
+
3787  // need to submit a claim transactions
+
3788  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
3789  .close();
+
3790  claim_cost += tx_fee;
+
3791  }
+
3792 
+
3793  BEAST_EXPECT(transfer.has_happened(amt, tiny_reward_split));
+
3794  BEAST_EXPECT(
+
3795  scAlice_bal.diff() == -(claim_cost - tiny_reward_remainder));
+
3796  }
3797 
-
3798  std::vector<Account> alt_payees{payees.begin(), payees.end() - 1};
-
3799  alt_payees.back() = Account("inexistent");
-
3800 
-
3801  scEnv.tx(create_bridge(Account::master, jvb))
-
3802  .tx(jtx::signers(Account::master, quorum, signers))
-
3803  .close()
-
3804  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3805  .close();
-
3806 
-
3807  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3808  auto const amt = XRP(1000);
-
3809  std::uint32_t const claimID = 1;
-
3810  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3811 
-
3812  BalanceTransfer transfer(
-
3813  scEnv,
-
3814  Account::master,
-
3815  scBob,
-
3816  scAlice,
-
3817  &payees[0],
-
3818  UT_XCHAIN_DEFAULT_QUORUM - 1,
-
3819  withClaim);
-
3820  scEnv.multiTx(claim_attestations(
-
3821  scAttester,
-
3822  jvb,
-
3823  mcAlice,
-
3824  amt,
-
3825  alt_payees,
-
3826  true,
-
3827  claimID,
-
3828  dst,
-
3829  signers));
-
3830 
-
3831  if (withClaim)
-
3832  {
-
3833  BEAST_EXPECT(transfer.has_not_happened());
-
3834 
-
3835  // need to submit a claim transactions
-
3836  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
3837  .close();
-
3838  }
-
3839 
-
3840  // this also checks that only 3 * split_reward was deducted from
-
3841  // scAlice (the payor account), since we passed alt_payees to
-
3842  // BalanceTransfer
-
3843  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
3844  }
-
3845 
-
3846  for (auto withClaim : {false, true})
-
3847  {
-
3848  XEnv mcEnv(*this);
-
3849  XEnv scEnv(*this, true);
-
3850 
-
3851  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-
3852  auto& unpaid = payees[UT_XCHAIN_DEFAULT_QUORUM - 1];
-
3853  scEnv.tx(create_bridge(Account::master, jvb))
-
3854  .tx(jtx::signers(Account::master, quorum, signers))
-
3855  .tx(fset(unpaid, asfDepositAuth))
-
3856  .close()
-
3857  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
3858  .close();
-
3859 
-
3860  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
-
3861  auto const amt = XRP(1000);
-
3862  std::uint32_t const claimID = 1;
-
3863  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
-
3864 
-
3865  // balance of last signer should not change (has deposit auth)
-
3866  Balance last_signer(scEnv, unpaid);
-
3867 
-
3868  // make sure all signers except the last one get the
-
3869  // split_reward
-
3870 
-
3871  BalanceTransfer transfer(
-
3872  scEnv,
-
3873  Account::master,
-
3874  scBob,
-
3875  scAlice,
-
3876  &payees[0],
-
3877  UT_XCHAIN_DEFAULT_QUORUM - 1,
-
3878  withClaim);
-
3879  scEnv.multiTx(claim_attestations(
-
3880  scAttester,
-
3881  jvb,
-
3882  mcAlice,
-
3883  amt,
-
3884  payees,
-
3885  true,
-
3886  claimID,
-
3887  dst,
-
3888  signers));
-
3889 
-
3890  if (withClaim)
-
3891  {
-
3892  BEAST_EXPECT(transfer.has_not_happened());
-
3893 
-
3894  // need to submit a claim transactions
-
3895  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
-
3896  .close();
-
3897  }
-
3898 
-
3899  // this also checks that only 3 * split_reward was deducted from
-
3900  // scAlice (the payor account), since we passed payees.size() -
-
3901  // 1 to BalanceTransfer
-
3902  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
-
3903 
-
3904  // and make sure the account with deposit auth received nothing
-
3905  BEAST_EXPECT(last_signer.diff() == STAmount(0));
-
3906  }
-
3907 
-
3908  // coverage test: xchain_claim transaction with incorrect flag
-
3909  XEnv(*this, true)
-
3910  .tx(create_bridge(Account::master, jvb))
-
3911  .close()
-
3912  .tx(xchain_claim(scAlice, jvb, 1, XRP(1000), scBob),
-
3913  txflags(tfFillOrKill),
-
3914  ter(temINVALID_FLAG))
-
3915  .close();
-
3916 
-
3917  // coverage test: xchain_claim transaction with xchain feature
-
3918  // disabled
-
3919  XEnv(*this, true)
-
3920  .tx(create_bridge(Account::master, jvb))
-
3921  .disableFeature(featureXChainBridge)
-
3922  .close()
-
3923  .tx(xchain_claim(scAlice, jvb, 1, XRP(1000), scBob),
-
3924  ter(temDISABLED))
-
3925  .close();
-
3926 
-
3927  // coverage test: XChainClaim::preclaim - isLockingChain = true;
-
3928  XEnv(*this)
-
3929  .tx(create_bridge(mcDoor, jvb))
-
3930  .close()
-
3931  .tx(xchain_claim(mcAlice, jvb, 1, XRP(1000), mcBob),
-
3932  ter(tecXCHAIN_NO_CLAIM_ID));
-
3933  }
-
3934 
-
3935  void
-
3936  testXChainCreateAccount()
-
3937  {
-
3938  using namespace jtx;
-
3939 
-
3940  testcase("Bridge Create Account");
-
3941  XRPAmount tx_fee = txFee();
-
3942 
-
3943  // coverage test: transferHelper() - dst == src
-
3944  {
-
3945  XEnv scEnv(*this, true);
+
3798  // If a reward distribution fails for one of the reward accounts
+
3799  // (the reward account doesn't exist or has deposit auth set), then
+
3800  // the txn should still succeed, but that portion should go to the
+
3801  // claim id owner.
+
3802  // -------------------------------------------------------------------
+
3803  for (auto withClaim : {false, true})
+
3804  {
+
3805  XEnv mcEnv(*this);
+
3806  XEnv scEnv(*this, true);
+
3807 
+
3808  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3809 
+
3810  std::vector<Account> alt_payees{payees.begin(), payees.end() - 1};
+
3811  alt_payees.back() = Account("inexistent");
+
3812 
+
3813  scEnv.tx(create_bridge(Account::master, jvb))
+
3814  .tx(jtx::signers(Account::master, quorum, signers))
+
3815  .close()
+
3816  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3817  .close();
+
3818 
+
3819  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3820  auto const amt = XRP(1000);
+
3821  std::uint32_t const claimID = 1;
+
3822  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3823 
+
3824  BalanceTransfer transfer(
+
3825  scEnv,
+
3826  Account::master,
+
3827  scBob,
+
3828  scAlice,
+
3829  &payees[0],
+
3830  UT_XCHAIN_DEFAULT_QUORUM - 1,
+
3831  withClaim);
+
3832  scEnv.multiTx(claim_attestations(
+
3833  scAttester,
+
3834  jvb,
+
3835  mcAlice,
+
3836  amt,
+
3837  alt_payees,
+
3838  true,
+
3839  claimID,
+
3840  dst,
+
3841  signers));
+
3842 
+
3843  if (withClaim)
+
3844  {
+
3845  BEAST_EXPECT(transfer.has_not_happened());
+
3846 
+
3847  // need to submit a claim transactions
+
3848  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
3849  .close();
+
3850  }
+
3851 
+
3852  // this also checks that only 3 * split_reward was deducted from
+
3853  // scAlice (the payor account), since we passed alt_payees to
+
3854  // BalanceTransfer
+
3855  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
3856  }
+
3857 
+
3858  for (auto withClaim : {false, true})
+
3859  {
+
3860  XEnv mcEnv(*this);
+
3861  XEnv scEnv(*this, true);
+
3862 
+
3863  mcEnv.tx(create_bridge(mcDoor, jvb)).close();
+
3864  auto& unpaid = payees[UT_XCHAIN_DEFAULT_QUORUM - 1];
+
3865  scEnv.tx(create_bridge(Account::master, jvb))
+
3866  .tx(jtx::signers(Account::master, quorum, signers))
+
3867  .tx(fset(unpaid, asfDepositAuth))
+
3868  .close()
+
3869  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
3870  .close();
+
3871 
+
3872  auto dst(withClaim ? std::nullopt : std::optional<Account>{scBob});
+
3873  auto const amt = XRP(1000);
+
3874  std::uint32_t const claimID = 1;
+
3875  mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
+
3876 
+
3877  // balance of last signer should not change (has deposit auth)
+
3878  Balance last_signer(scEnv, unpaid);
+
3879 
+
3880  // make sure all signers except the last one get the
+
3881  // split_reward
+
3882 
+
3883  BalanceTransfer transfer(
+
3884  scEnv,
+
3885  Account::master,
+
3886  scBob,
+
3887  scAlice,
+
3888  &payees[0],
+
3889  UT_XCHAIN_DEFAULT_QUORUM - 1,
+
3890  withClaim);
+
3891  scEnv.multiTx(claim_attestations(
+
3892  scAttester,
+
3893  jvb,
+
3894  mcAlice,
+
3895  amt,
+
3896  payees,
+
3897  true,
+
3898  claimID,
+
3899  dst,
+
3900  signers));
+
3901 
+
3902  if (withClaim)
+
3903  {
+
3904  BEAST_EXPECT(transfer.has_not_happened());
+
3905 
+
3906  // need to submit a claim transactions
+
3907  scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scBob))
+
3908  .close();
+
3909  }
+
3910 
+
3911  // this also checks that only 3 * split_reward was deducted from
+
3912  // scAlice (the payor account), since we passed payees.size() -
+
3913  // 1 to BalanceTransfer
+
3914  BEAST_EXPECT(transfer.has_happened(amt, split_reward_quorum));
+
3915 
+
3916  // and make sure the account with deposit auth received nothing
+
3917  BEAST_EXPECT(last_signer.diff() == STAmount(0));
+
3918  }
+
3919 
+
3920  // coverage test: xchain_claim transaction with incorrect flag
+
3921  XEnv(*this, true)
+
3922  .tx(create_bridge(Account::master, jvb))
+
3923  .close()
+
3924  .tx(xchain_claim(scAlice, jvb, 1, XRP(1000), scBob),
+
3925  txflags(tfFillOrKill),
+
3926  ter(temINVALID_FLAG))
+
3927  .close();
+
3928 
+
3929  // coverage test: xchain_claim transaction with xchain feature
+
3930  // disabled
+
3931  XEnv(*this, true)
+
3932  .tx(create_bridge(Account::master, jvb))
+
3933  .disableFeature(featureXChainBridge)
+
3934  .close()
+
3935  .tx(xchain_claim(scAlice, jvb, 1, XRP(1000), scBob),
+
3936  ter(temDISABLED))
+
3937  .close();
+
3938 
+
3939  // coverage test: XChainClaim::preclaim - isLockingChain = true;
+
3940  XEnv(*this)
+
3941  .tx(create_bridge(mcDoor, jvb))
+
3942  .close()
+
3943  .tx(xchain_claim(mcAlice, jvb, 1, XRP(1000), mcBob),
+
3944  ter(tecXCHAIN_NO_CLAIM_ID));
+
3945  }
3946 
-
3947  auto const amt = XRP(111);
-
3948  auto const amt_plus_reward = amt + reward;
-
3949 
-
3950  scEnv.tx(create_bridge(Account::master, jvb))
-
3951  .tx(jtx::signers(Account::master, quorum, signers))
-
3952  .close();
-
3953 
-
3954  Balance door(scEnv, Account::master);
-
3955 
-
3956  // scEnv.tx(att_create_acct_batch1(1, amt,
-
3957  // Account::master)).close();
-
3958  scEnv.multiTx(att_create_acct_vec(1, amt, Account::master, 2))
-
3959  .close();
-
3960  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
-
3961  BEAST_EXPECT(
-
3962  scEnv.claimCount(jvb) == 0); // claim count is one less
-
3963 
-
3964  // scEnv.tx(att_create_acct_batch2(1, amt,
-
3965  // Account::master)).close();
-
3966  scEnv.multiTx(att_create_acct_vec(1, amt, Account::master, 2, 2))
-
3967  .close();
-
3968  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
-
3969  BEAST_EXPECT(
-
3970  scEnv.claimCount(jvb) == 1); // claim count was incremented
-
3971 
-
3972  BEAST_EXPECT(door.diff() == -reward);
-
3973  }
-
3974 
-
3975  // Check that creating an account with less than the minimum create
-
3976  // amount fails.
-
3977  {
-
3978  XEnv mcEnv(*this);
-
3979 
-
3980  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
3981 
-
3982  Balance door(mcEnv, mcDoor);
-
3983  Balance carol(mcEnv, mcCarol);
-
3984 
-
3985  mcEnv
-
3986  .tx(sidechain_xchain_account_create(
-
3987  mcCarol, jvb, scuAlice, XRP(19), reward),
-
3988  ter(tecXCHAIN_INSUFF_CREATE_AMOUNT))
-
3989  .close();
-
3990 
-
3991  BEAST_EXPECT(door.diff() == STAmount(0));
-
3992  BEAST_EXPECT(carol.diff() == -tx_fee);
-
3993  }
-
3994 
-
3995  // Check that creating an account with invalid flags fails.
-
3996  {
-
3997  XEnv mcEnv(*this);
-
3998 
-
3999  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
4000 
-
4001  Balance door(mcEnv, mcDoor);
+
3947  void
+
3948  testXChainCreateAccount()
+
3949  {
+
3950  using namespace jtx;
+
3951 
+
3952  testcase("Bridge Create Account");
+
3953  XRPAmount tx_fee = txFee();
+
3954 
+
3955  // coverage test: transferHelper() - dst == src
+
3956  {
+
3957  XEnv scEnv(*this, true);
+
3958 
+
3959  auto const amt = XRP(111);
+
3960  auto const amt_plus_reward = amt + reward;
+
3961 
+
3962  scEnv.tx(create_bridge(Account::master, jvb))
+
3963  .tx(jtx::signers(Account::master, quorum, signers))
+
3964  .close();
+
3965 
+
3966  Balance door(scEnv, Account::master);
+
3967 
+
3968  // scEnv.tx(att_create_acct_batch1(1, amt,
+
3969  // Account::master)).close();
+
3970  scEnv.multiTx(att_create_acct_vec(1, amt, Account::master, 2))
+
3971  .close();
+
3972  BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1)); // claim id present
+
3973  BEAST_EXPECT(
+
3974  scEnv.claimCount(jvb) == 0); // claim count is one less
+
3975 
+
3976  // scEnv.tx(att_create_acct_batch2(1, amt,
+
3977  // Account::master)).close();
+
3978  scEnv.multiTx(att_create_acct_vec(1, amt, Account::master, 2, 2))
+
3979  .close();
+
3980  BEAST_EXPECT(!scEnv.caClaimID(jvb, 1)); // claim id deleted
+
3981  BEAST_EXPECT(
+
3982  scEnv.claimCount(jvb) == 1); // claim count was incremented
+
3983 
+
3984  BEAST_EXPECT(door.diff() == -reward);
+
3985  }
+
3986 
+
3987  // Check that creating an account with less than the minimum create
+
3988  // amount fails.
+
3989  {
+
3990  XEnv mcEnv(*this);
+
3991 
+
3992  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
+
3993 
+
3994  Balance door(mcEnv, mcDoor);
+
3995  Balance carol(mcEnv, mcCarol);
+
3996 
+
3997  mcEnv
+
3998  .tx(sidechain_xchain_account_create(
+
3999  mcCarol, jvb, scuAlice, XRP(19), reward),
+
4000  ter(tecXCHAIN_INSUFF_CREATE_AMOUNT))
+
4001  .close();
4002 
-
4003  mcEnv
-
4004  .tx(sidechain_xchain_account_create(
-
4005  mcCarol, jvb, scuAlice, XRP(20), reward),
-
4006  txflags(tfFillOrKill),
-
4007  ter(temINVALID_FLAG))
-
4008  .close();
-
4009 
-
4010  BEAST_EXPECT(door.diff() == STAmount(0));
-
4011  }
+
4003  BEAST_EXPECT(door.diff() == STAmount(0));
+
4004  BEAST_EXPECT(carol.diff() == -tx_fee);
+
4005  }
+
4006 
+
4007  // Check that creating an account with invalid flags fails.
+
4008  {
+
4009  XEnv mcEnv(*this);
+
4010 
+
4011  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
4012 
-
4013  // Check that creating an account with the XChainBridge feature
-
4014  // disabled fails.
-
4015  {
-
4016  XEnv mcEnv(*this);
-
4017 
-
4018  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
4019 
-
4020  Balance door(mcEnv, mcDoor);
+
4013  Balance door(mcEnv, mcDoor);
+
4014 
+
4015  mcEnv
+
4016  .tx(sidechain_xchain_account_create(
+
4017  mcCarol, jvb, scuAlice, XRP(20), reward),
+
4018  txflags(tfFillOrKill),
+
4019  ter(temINVALID_FLAG))
+
4020  .close();
4021 
-
4022  mcEnv.disableFeature(featureXChainBridge)
-
4023  .tx(sidechain_xchain_account_create(
-
4024  mcCarol, jvb, scuAlice, XRP(20), reward),
-
4025  ter(temDISABLED))
-
4026  .close();
-
4027 
-
4028  BEAST_EXPECT(door.diff() == STAmount(0));
-
4029  }
-
4030 
-
4031  // Check that creating an account with a negative amount fails
-
4032  {
-
4033  XEnv mcEnv(*this);
-
4034 
-
4035  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
4036 
-
4037  Balance door(mcEnv, mcDoor);
-
4038 
-
4039  mcEnv
-
4040  .tx(sidechain_xchain_account_create(
-
4041  mcCarol, jvb, scuAlice, XRP(-20), reward),
-
4042  ter(temBAD_AMOUNT))
-
4043  .close();
-
4044 
-
4045  BEAST_EXPECT(door.diff() == STAmount(0));
-
4046  }
-
4047 
-
4048  // Check that creating an account with a negative reward fails
-
4049  {
-
4050  XEnv mcEnv(*this);
-
4051 
-
4052  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
4053 
-
4054  Balance door(mcEnv, mcDoor);
-
4055 
-
4056  mcEnv
-
4057  .tx(sidechain_xchain_account_create(
-
4058  mcCarol, jvb, scuAlice, XRP(20), XRP(-1)),
-
4059  ter(temBAD_AMOUNT))
-
4060  .close();
-
4061 
-
4062  BEAST_EXPECT(door.diff() == STAmount(0));
-
4063  }
-
4064 
-
4065  // Check that door account can't lock funds onto itself
-
4066  {
-
4067  XEnv mcEnv(*this);
-
4068 
-
4069  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
4070 
-
4071  Balance door(mcEnv, mcDoor);
-
4072 
-
4073  mcEnv
-
4074  .tx(sidechain_xchain_account_create(
-
4075  mcDoor, jvb, scuAlice, XRP(20), XRP(1)),
-
4076  ter(tecXCHAIN_SELF_COMMIT))
-
4077  .close();
-
4078 
-
4079  BEAST_EXPECT(door.diff() == -tx_fee);
-
4080  }
-
4081 
-
4082  // Check that reward matches the amount specified in bridge
-
4083  {
-
4084  XEnv mcEnv(*this);
-
4085 
-
4086  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
-
4087 
-
4088  Balance door(mcEnv, mcDoor);
-
4089 
-
4090  mcEnv
-
4091  .tx(sidechain_xchain_account_create(
-
4092  mcCarol, jvb, scuAlice, XRP(20), XRP(2)),
-
4093  ter(tecXCHAIN_REWARD_MISMATCH))
-
4094  .close();
-
4095 
-
4096  BEAST_EXPECT(door.diff() == STAmount(0));
-
4097  }
-
4098  }
+
4022  BEAST_EXPECT(door.diff() == STAmount(0));
+
4023  }
+
4024 
+
4025  // Check that creating an account with the XChainBridge feature
+
4026  // disabled fails.
+
4027  {
+
4028  XEnv mcEnv(*this);
+
4029 
+
4030  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
+
4031 
+
4032  Balance door(mcEnv, mcDoor);
+
4033 
+
4034  mcEnv.disableFeature(featureXChainBridge)
+
4035  .tx(sidechain_xchain_account_create(
+
4036  mcCarol, jvb, scuAlice, XRP(20), reward),
+
4037  ter(temDISABLED))
+
4038  .close();
+
4039 
+
4040  BEAST_EXPECT(door.diff() == STAmount(0));
+
4041  }
+
4042 
+
4043  // Check that creating an account with a negative amount fails
+
4044  {
+
4045  XEnv mcEnv(*this);
+
4046 
+
4047  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
+
4048 
+
4049  Balance door(mcEnv, mcDoor);
+
4050 
+
4051  mcEnv
+
4052  .tx(sidechain_xchain_account_create(
+
4053  mcCarol, jvb, scuAlice, XRP(-20), reward),
+
4054  ter(temBAD_AMOUNT))
+
4055  .close();
+
4056 
+
4057  BEAST_EXPECT(door.diff() == STAmount(0));
+
4058  }
+
4059 
+
4060  // Check that creating an account with a negative reward fails
+
4061  {
+
4062  XEnv mcEnv(*this);
+
4063 
+
4064  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
+
4065 
+
4066  Balance door(mcEnv, mcDoor);
+
4067 
+
4068  mcEnv
+
4069  .tx(sidechain_xchain_account_create(
+
4070  mcCarol, jvb, scuAlice, XRP(20), XRP(-1)),
+
4071  ter(temBAD_AMOUNT))
+
4072  .close();
+
4073 
+
4074  BEAST_EXPECT(door.diff() == STAmount(0));
+
4075  }
+
4076 
+
4077  // Check that door account can't lock funds onto itself
+
4078  {
+
4079  XEnv mcEnv(*this);
+
4080 
+
4081  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
+
4082 
+
4083  Balance door(mcEnv, mcDoor);
+
4084 
+
4085  mcEnv
+
4086  .tx(sidechain_xchain_account_create(
+
4087  mcDoor, jvb, scuAlice, XRP(20), XRP(1)),
+
4088  ter(tecXCHAIN_SELF_COMMIT))
+
4089  .close();
+
4090 
+
4091  BEAST_EXPECT(door.diff() == -tx_fee);
+
4092  }
+
4093 
+
4094  // Check that reward matches the amount specified in bridge
+
4095  {
+
4096  XEnv mcEnv(*this);
+
4097 
+
4098  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
4099 
-
4100  void
-
4101  testFeeDipsIntoReserve()
-
4102  {
-
4103  using namespace jtx;
-
4104  XRPAmount res0 = reserve(0);
-
4105  XRPAmount tx_fee = txFee();
-
4106 
-
4107  testcase("Fee dips into reserve");
-
4108 
-
4109  // commit where the fee dips into the reserve, this should succeed
-
4110  XEnv(*this)
-
4111  .tx(create_bridge(mcDoor, jvb))
-
4112  .fund(res0 + one_xrp + tx_fee - drops(1), mcuAlice)
-
4113  .close()
-
4114  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob),
-
4115  ter(tesSUCCESS));
-
4116 
-
4117  // commit where the commit amount drips into the reserve, this should
-
4118  // fail
-
4119  XEnv(*this)
-
4120  .tx(create_bridge(mcDoor, jvb))
-
4121  .fund(res0 + one_xrp - drops(1), mcuAlice)
-
4122  .close()
-
4123  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob),
-
4124  ter(tecUNFUNDED_PAYMENT));
-
4125 
-
4126  auto const minAccountCreate = XRP(20);
-
4127 
-
4128  // account create commit where the fee dips into the reserve,
-
4129  // this should succeed
-
4130  XEnv(*this)
-
4131  .tx(create_bridge(mcDoor, jvb, reward, minAccountCreate))
-
4132  .fund(
-
4133  res0 + tx_fee + minAccountCreate + reward - drops(1), mcuAlice)
+
4100  Balance door(mcEnv, mcDoor);
+
4101 
+
4102  mcEnv
+
4103  .tx(sidechain_xchain_account_create(
+
4104  mcCarol, jvb, scuAlice, XRP(20), XRP(2)),
+
4105  ter(tecXCHAIN_REWARD_MISMATCH))
+
4106  .close();
+
4107 
+
4108  BEAST_EXPECT(door.diff() == STAmount(0));
+
4109  }
+
4110  }
+
4111 
+
4112  void
+
4113  testFeeDipsIntoReserve()
+
4114  {
+
4115  using namespace jtx;
+
4116  XRPAmount res0 = reserve(0);
+
4117  XRPAmount tx_fee = txFee();
+
4118 
+
4119  testcase("Fee dips into reserve");
+
4120 
+
4121  // commit where the fee dips into the reserve, this should succeed
+
4122  XEnv(*this)
+
4123  .tx(create_bridge(mcDoor, jvb))
+
4124  .fund(res0 + one_xrp + tx_fee - drops(1), mcuAlice)
+
4125  .close()
+
4126  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob),
+
4127  ter(tesSUCCESS));
+
4128 
+
4129  // commit where the commit amount drips into the reserve, this should
+
4130  // fail
+
4131  XEnv(*this)
+
4132  .tx(create_bridge(mcDoor, jvb))
+
4133  .fund(res0 + one_xrp - drops(1), mcuAlice)
4134  .close()
-
4135  .tx(sidechain_xchain_account_create(
-
4136  mcuAlice, jvb, scuAlice, minAccountCreate, reward),
-
4137  ter(tesSUCCESS));
-
4138 
-
4139  // account create commit where the commit dips into the reserve,
-
4140  // this should fail
-
4141  XEnv(*this)
-
4142  .tx(create_bridge(mcDoor, jvb, reward, minAccountCreate))
-
4143  .fund(res0 + minAccountCreate + reward - drops(1), mcuAlice)
-
4144  .close()
-
4145  .tx(sidechain_xchain_account_create(
-
4146  mcuAlice, jvb, scuAlice, minAccountCreate, reward),
-
4147  ter(tecUNFUNDED_PAYMENT));
-
4148  }
-
4149 
-
4150  void
-
4151  testXChainDeleteDoor()
-
4152  {
-
4153  using namespace jtx;
-
4154 
-
4155  testcase("Bridge Delete Door Account");
-
4156 
-
4157  auto const acctDelFee{
-
4158  drops(XEnv(*this).env_.current()->fees().increment)};
-
4159 
-
4160  // Deleting an account that owns bridge should fail
-
4161  {
-
4162  XEnv mcEnv(*this);
-
4163 
-
4164  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(1))).close();
-
4165 
-
4166  // We don't allow an account to be deleted if its sequence
-
4167  // number is within 256 of the current ledger.
-
4168  for (size_t i = 0; i < 256; ++i)
-
4169  mcEnv.close();
-
4170 
-
4171  // try to delete mcDoor, send funds to mcAlice
-
4172  mcEnv.tx(
-
4173  acctdelete(mcDoor, mcAlice),
-
4174  fee(acctDelFee),
-
4175  ter(tecHAS_OBLIGATIONS));
-
4176  }
+
4135  .tx(xchain_commit(mcuAlice, jvb, 1, one_xrp, scBob),
+
4136  ter(tecUNFUNDED_PAYMENT));
+
4137 
+
4138  auto const minAccountCreate = XRP(20);
+
4139 
+
4140  // account create commit where the fee dips into the reserve,
+
4141  // this should succeed
+
4142  XEnv(*this)
+
4143  .tx(create_bridge(mcDoor, jvb, reward, minAccountCreate))
+
4144  .fund(
+
4145  res0 + tx_fee + minAccountCreate + reward - drops(1), mcuAlice)
+
4146  .close()
+
4147  .tx(sidechain_xchain_account_create(
+
4148  mcuAlice, jvb, scuAlice, minAccountCreate, reward),
+
4149  ter(tesSUCCESS));
+
4150 
+
4151  // account create commit where the commit dips into the reserve,
+
4152  // this should fail
+
4153  XEnv(*this)
+
4154  .tx(create_bridge(mcDoor, jvb, reward, minAccountCreate))
+
4155  .fund(res0 + minAccountCreate + reward - drops(1), mcuAlice)
+
4156  .close()
+
4157  .tx(sidechain_xchain_account_create(
+
4158  mcuAlice, jvb, scuAlice, minAccountCreate, reward),
+
4159  ter(tecUNFUNDED_PAYMENT));
+
4160  }
+
4161 
+
4162  void
+
4163  testXChainDeleteDoor()
+
4164  {
+
4165  using namespace jtx;
+
4166 
+
4167  testcase("Bridge Delete Door Account");
+
4168 
+
4169  auto const acctDelFee{
+
4170  drops(XEnv(*this).env_.current()->fees().increment)};
+
4171 
+
4172  // Deleting an account that owns bridge should fail
+
4173  {
+
4174  XEnv mcEnv(*this);
+
4175 
+
4176  mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(1))).close();
4177 
-
4178  // Deleting an account that owns a claim id should fail
-
4179  {
-
4180  XEnv scEnv(*this, true);
-
4181 
-
4182  scEnv.tx(create_bridge(Account::master, jvb))
-
4183  .close()
-
4184  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
-
4185  .close();
-
4186 
-
4187  // We don't allow an account to be deleted if its sequence
-
4188  // number is within 256 of the current ledger.
-
4189  for (size_t i = 0; i < 256; ++i)
-
4190  scEnv.close();
-
4191 
-
4192  // try to delete scAlice, send funds to scBob
-
4193  scEnv.tx(
-
4194  acctdelete(scAlice, scBob),
-
4195  fee(acctDelFee),
-
4196  ter(tecHAS_OBLIGATIONS));
-
4197  }
-
4198  }
-
4199 
-
4200  void
-
4201  run() override
-
4202  {
-
4203  testXChainBridgeExtraFields();
-
4204  testXChainCreateBridge();
-
4205  testXChainBridgeCreateConstraints();
-
4206  testXChainCreateBridgeMatrix();
-
4207  testXChainModifyBridge();
-
4208  testXChainCreateClaimID();
-
4209  testXChainCommit();
-
4210  testXChainAddAttestation();
-
4211  testXChainAddClaimNonBatchAttestation();
-
4212  testXChainAddAccountCreateNonBatchAttestation();
-
4213  testXChainClaim();
-
4214  testXChainCreateAccount();
-
4215  testFeeDipsIntoReserve();
-
4216  testXChainDeleteDoor();
-
4217  }
-
4218 };
-
4219 
-
4220 // -----------------------------------------------------------
-
4221 // -----------------------------------------------------------
-
4222 struct XChainSim_test : public beast::unit_test::suite,
-
4223  public jtx::XChainBridgeObjects
-
4224 {
-
4225 private:
-
4226  static constexpr size_t num_signers = 5;
-
4227 
-
4228  // --------------------------------------------------
-
4229  enum class WithClaim { no, yes };
-
4230  struct Transfer
-
4231  {
-
4232  jtx::Account from;
-
4233  jtx::Account to;
-
4234  jtx::Account finaldest;
-
4235  STAmount amt;
-
4236  bool a2b; // direction of transfer
-
4237  WithClaim with_claim{WithClaim::no};
-
4238  uint32_t claim_id{0};
-
4239  std::array<bool, num_signers> attested{};
-
4240  };
-
4241 
-
4242  struct AccountCreate
+
4178  // We don't allow an account to be deleted if its sequence
+
4179  // number is within 256 of the current ledger.
+
4180  for (size_t i = 0; i < 256; ++i)
+
4181  mcEnv.close();
+
4182 
+
4183  // try to delete mcDoor, send funds to mcAlice
+
4184  mcEnv.tx(
+
4185  acctdelete(mcDoor, mcAlice),
+
4186  fee(acctDelFee),
+
4187  ter(tecHAS_OBLIGATIONS));
+
4188  }
+
4189 
+
4190  // Deleting an account that owns a claim id should fail
+
4191  {
+
4192  XEnv scEnv(*this, true);
+
4193 
+
4194  scEnv.tx(create_bridge(Account::master, jvb))
+
4195  .close()
+
4196  .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
+
4197  .close();
+
4198 
+
4199  // We don't allow an account to be deleted if its sequence
+
4200  // number is within 256 of the current ledger.
+
4201  for (size_t i = 0; i < 256; ++i)
+
4202  scEnv.close();
+
4203 
+
4204  // try to delete scAlice, send funds to scBob
+
4205  scEnv.tx(
+
4206  acctdelete(scAlice, scBob),
+
4207  fee(acctDelFee),
+
4208  ter(tecHAS_OBLIGATIONS));
+
4209  }
+
4210  }
+
4211 
+
4212  void
+
4213  run() override
+
4214  {
+
4215  testXChainBridgeExtraFields();
+
4216  testXChainCreateBridge();
+
4217  testXChainBridgeCreateConstraints();
+
4218  testXChainCreateBridgeMatrix();
+
4219  testXChainModifyBridge();
+
4220  testXChainCreateClaimID();
+
4221  testXChainCommit();
+
4222  testXChainAddAttestation();
+
4223  testXChainAddClaimNonBatchAttestation();
+
4224  testXChainAddAccountCreateNonBatchAttestation();
+
4225  testXChainClaim();
+
4226  testXChainCreateAccount();
+
4227  testFeeDipsIntoReserve();
+
4228  testXChainDeleteDoor();
+
4229  }
+
4230 };
+
4231 
+
4232 // -----------------------------------------------------------
+
4233 // -----------------------------------------------------------
+
4234 struct XChainSim_test : public beast::unit_test::suite,
+
4235  public jtx::XChainBridgeObjects
+
4236 {
+
4237 private:
+
4238  static constexpr size_t num_signers = 5;
+
4239 
+
4240  // --------------------------------------------------
+
4241  enum class WithClaim { no, yes };
+
4242  struct Transfer
4243  {
-
4244  jtx::Account from;
-
4245  jtx::Account to;
-
4246  STAmount amt;
-
4247  STAmount reward;
-
4248  bool a2b;
-
4249  uint32_t claim_id{0};
-
4250  std::array<bool, num_signers> attested{};
-
4251  };
-
4252 
-
4253  using ENV = XEnv<XChainSim_test>;
-
4254  using BridgeID = BridgeDef const*;
-
4255 
-
4256  // tracking chain state
-
4257  // --------------------
-
4258  struct AccountStateTrack
-
4259  {
-
4260  STAmount startAmount{0};
-
4261  STAmount expectedDiff{0};
-
4262 
-
4263  void
-
4264  init(ENV& env, jtx::Account const& acct)
-
4265  {
-
4266  startAmount = env.balance(acct);
-
4267  expectedDiff = STAmount(0);
-
4268  }
-
4269 
-
4270  bool
-
4271  verify(ENV& env, jtx::Account const& acct) const
-
4272  {
-
4273  STAmount diff{env.balance(acct) - startAmount};
-
4274  bool check = diff == expectedDiff;
-
4275  return check;
-
4276  }
-
4277  };
-
4278 
-
4279  // --------------------------------------------------
-
4280  struct ChainStateTrack
-
4281  {
-
4282  using ClaimVec = jtx::JValueVec;
-
4283  using CreateClaimVec = jtx::JValueVec;
-
4284  using CreateClaimMap = std::map<uint32_t, CreateClaimVec>;
-
4285 
-
4286  ChainStateTrack(ENV& env)
-
4287  : env(env), tx_fee(env.env_.current()->fees().base)
-
4288  {
-
4289  }
+
4244  jtx::Account from;
+
4245  jtx::Account to;
+
4246  jtx::Account finaldest;
+
4247  STAmount amt;
+
4248  bool a2b; // direction of transfer
+
4249  WithClaim with_claim{WithClaim::no};
+
4250  uint32_t claim_id{0};
+
4251  std::array<bool, num_signers> attested{};
+
4252  };
+
4253 
+
4254  struct AccountCreate
+
4255  {
+
4256  jtx::Account from;
+
4257  jtx::Account to;
+
4258  STAmount amt;
+
4259  STAmount reward;
+
4260  bool a2b;
+
4261  uint32_t claim_id{0};
+
4262  std::array<bool, num_signers> attested{};
+
4263  };
+
4264 
+
4265  using ENV = XEnv<XChainSim_test>;
+
4266  using BridgeID = BridgeDef const*;
+
4267 
+
4268  // tracking chain state
+
4269  // --------------------
+
4270  struct AccountStateTrack
+
4271  {
+
4272  STAmount startAmount{0};
+
4273  STAmount expectedDiff{0};
+
4274 
+
4275  void
+
4276  init(ENV& env, jtx::Account const& acct)
+
4277  {
+
4278  startAmount = env.balance(acct);
+
4279  expectedDiff = STAmount(0);
+
4280  }
+
4281 
+
4282  bool
+
4283  verify(ENV& env, jtx::Account const& acct) const
+
4284  {
+
4285  STAmount diff{env.balance(acct) - startAmount};
+
4286  bool check = diff == expectedDiff;
+
4287  return check;
+
4288  }
+
4289  };
4290 
-
4291  void
-
4292  sendAttestations(size_t signer_idx, BridgeID bridge, ClaimVec& claims)
-
4293  {
-
4294  for (auto const& c : claims)
-
4295  {
-
4296  env.tx(c).close();
-
4297  spendFee(bridge->signers[signer_idx].account);
-
4298  }
-
4299  claims.clear();
-
4300  }
-
4301 
-
4302  uint32_t
-
4303  sendCreateAttestations(
-
4304  size_t signer_idx,
-
4305  BridgeID bridge,
-
4306  CreateClaimVec& claims)
-
4307  {
-
4308  size_t num_successful = 0;
-
4309  for (auto const& c : claims)
-
4310  {
-
4311  env.tx(c).close();
-
4312  if (env.ter() == tesSUCCESS)
-
4313  {
-
4314  counters[bridge].signers.push_back(signer_idx);
-
4315  num_successful++;
-
4316  }
-
4317  spendFee(bridge->signers[signer_idx].account);
-
4318  }
-
4319  claims.clear();
-
4320  return num_successful;
-
4321  }
-
4322 
-
4323  void
-
4324  sendAttestations()
-
4325  {
-
4326  bool callback_called;
-
4327 
-
4328  // we have this "do {} while" loop because we want to process
-
4329  // all the account create which can reach quorum at this time
-
4330  // stamp.
-
4331  do
-
4332  {
-
4333  callback_called = false;
-
4334  for (size_t i = 0; i < signers_attns.size(); ++i)
-
4335  {
-
4336  for (auto& [bridge, claims] : signers_attns[i])
-
4337  {
-
4338  sendAttestations(i, bridge, claims.xfer_claims);
+
4291  // --------------------------------------------------
+
4292  struct ChainStateTrack
+
4293  {
+
4294  using ClaimVec = jtx::JValueVec;
+
4295  using CreateClaimVec = jtx::JValueVec;
+
4296  using CreateClaimMap = std::map<uint32_t, CreateClaimVec>;
+
4297 
+
4298  ChainStateTrack(ENV& env)
+
4299  : env(env), tx_fee(env.env_.current()->fees().base)
+
4300  {
+
4301  }
+
4302 
+
4303  void
+
4304  sendAttestations(size_t signer_idx, BridgeID bridge, ClaimVec& claims)
+
4305  {
+
4306  for (auto const& c : claims)
+
4307  {
+
4308  env.tx(c).close();
+
4309  spendFee(bridge->signers[signer_idx].account);
+
4310  }
+
4311  claims.clear();
+
4312  }
+
4313 
+
4314  uint32_t
+
4315  sendCreateAttestations(
+
4316  size_t signer_idx,
+
4317  BridgeID bridge,
+
4318  CreateClaimVec& claims)
+
4319  {
+
4320  size_t num_successful = 0;
+
4321  for (auto const& c : claims)
+
4322  {
+
4323  env.tx(c).close();
+
4324  if (env.ter() == tesSUCCESS)
+
4325  {
+
4326  counters[bridge].signers.push_back(signer_idx);
+
4327  num_successful++;
+
4328  }
+
4329  spendFee(bridge->signers[signer_idx].account);
+
4330  }
+
4331  claims.clear();
+
4332  return num_successful;
+
4333  }
+
4334 
+
4335  void
+
4336  sendAttestations()
+
4337  {
+
4338  bool callback_called;
4339 
-
4340  auto& c = counters[bridge];
-
4341  auto& create_claims =
-
4342  claims.create_claims[c.claim_count];
-
4343  auto num_attns = create_claims.size();
-
4344  if (num_attns)
-
4345  {
-
4346  c.num_create_attn_sent += sendCreateAttestations(
-
4347  i, bridge, create_claims);
-
4348  }
-
4349  assert(claims.create_claims[c.claim_count].empty());
-
4350  }
-
4351  }
-
4352  for (auto& [bridge, c] : counters)
-
4353  {
-
4354  if (c.num_create_attn_sent >= bridge->quorum)
-
4355  {
-
4356  callback_called = true;
-
4357  c.create_callbacks[c.claim_count](c.signers);
-
4358  ++c.claim_count;
-
4359  c.num_create_attn_sent = 0;
-
4360  c.signers.clear();
-
4361  }
-
4362  }
-
4363  } while (callback_called);
-
4364  }
-
4365 
-
4366  void
-
4367  init(jtx::Account const& acct)
-
4368  {
-
4369  accounts[acct].init(env, acct);
-
4370  }
-
4371 
-
4372  void
-
4373  receive(
-
4374  jtx::Account const& acct,
-
4375  STAmount amt,
-
4376  std::uint64_t divisor = 1)
-
4377  {
-
4378  if (amt.issue() != xrpIssue())
-
4379  return;
-
4380  auto it = accounts.find(acct);
-
4381  if (it == accounts.end())
-
4382  {
-
4383  accounts[acct].init(env, acct);
-
4384  // we just looked up the account, so expectedDiff == 0
-
4385  }
-
4386  else
-
4387  {
-
4388  it->second.expectedDiff +=
-
4389  (divisor == 1 ? amt
-
4390  : divide(
-
4391  amt,
-
4392  STAmount(amt.issue(), divisor),
-
4393  amt.issue()));
-
4394  }
-
4395  }
-
4396 
-
4397  void
-
4398  spend(jtx::Account const& acct, STAmount amt, std::uint64_t times = 1)
-
4399  {
-
4400  if (amt.issue() != xrpIssue())
-
4401  return;
-
4402  receive(
-
4403  acct,
-
4404  times == 1
-
4405  ? -amt
-
4406  : -multiply(
-
4407  amt, STAmount(amt.issue(), times), amt.issue()));
-
4408  }
-
4409 
-
4410  void
-
4411  transfer(jtx::Account const& from, jtx::Account const& to, STAmount amt)
-
4412  {
-
4413  spend(from, amt);
-
4414  receive(to, amt);
-
4415  }
-
4416 
-
4417  void
-
4418  spendFee(jtx::Account const& acct, size_t times = 1)
-
4419  {
-
4420  spend(acct, tx_fee, times);
-
4421  }
-
4422 
-
4423  bool
-
4424  verify() const
-
4425  {
-
4426  for (auto const& [acct, state] : accounts)
-
4427  if (!state.verify(env, acct))
-
4428  return false;
-
4429  return true;
-
4430  }
-
4431 
-
4432  struct BridgeCounters
-
4433  {
-
4434  using complete_cb =
-
4435  std::function<void(std::vector<size_t> const& signers)>;
-
4436 
-
4437  uint32_t claim_id{0};
-
4438  uint32_t create_count{0}; // for account create. First should be 1
-
4439  uint32_t claim_count{
-
4440  0}; // for account create. Increments after quorum for
-
4441  // current create_count (starts at 1) is reached.
-
4442 
-
4443  uint32_t num_create_attn_sent{0}; // for current claim_count
-
4444  std::vector<size_t> signers;
-
4445  std::vector<complete_cb> create_callbacks;
-
4446  };
-
4447 
-
4448  struct Claims
-
4449  {
-
4450  ClaimVec xfer_claims;
-
4451  CreateClaimMap create_claims;
-
4452  };
-
4453 
-
4454  using SignerAttns = std::unordered_map<BridgeID, Claims>;
-
4455  using SignersAttns = std::array<SignerAttns, num_signers>;
-
4456 
-
4457  ENV& env;
-
4458  std::map<jtx::Account, AccountStateTrack> accounts;
-
4459  SignersAttns signers_attns;
-
4460  std::map<BridgeID, BridgeCounters> counters;
-
4461  STAmount tx_fee;
-
4462  };
-
4463 
-
4464  struct ChainStateTracker
-
4465  {
-
4466  ChainStateTracker(ENV& a_env, ENV& b_env) : a_(a_env), b_(b_env)
-
4467  {
-
4468  }
-
4469 
-
4470  bool
-
4471  verify() const
-
4472  {
-
4473  return a_.verify() && b_.verify();
-
4474  }
+
4340  // we have this "do {} while" loop because we want to process
+
4341  // all the account create which can reach quorum at this time
+
4342  // stamp.
+
4343  do
+
4344  {
+
4345  callback_called = false;
+
4346  for (size_t i = 0; i < signers_attns.size(); ++i)
+
4347  {
+
4348  for (auto& [bridge, claims] : signers_attns[i])
+
4349  {
+
4350  sendAttestations(i, bridge, claims.xfer_claims);
+
4351 
+
4352  auto& c = counters[bridge];
+
4353  auto& create_claims =
+
4354  claims.create_claims[c.claim_count];
+
4355  auto num_attns = create_claims.size();
+
4356  if (num_attns)
+
4357  {
+
4358  c.num_create_attn_sent += sendCreateAttestations(
+
4359  i, bridge, create_claims);
+
4360  }
+
4361  assert(claims.create_claims[c.claim_count].empty());
+
4362  }
+
4363  }
+
4364  for (auto& [bridge, c] : counters)
+
4365  {
+
4366  if (c.num_create_attn_sent >= bridge->quorum)
+
4367  {
+
4368  callback_called = true;
+
4369  c.create_callbacks[c.claim_count](c.signers);
+
4370  ++c.claim_count;
+
4371  c.num_create_attn_sent = 0;
+
4372  c.signers.clear();
+
4373  }
+
4374  }
+
4375  } while (callback_called);
+
4376  }
+
4377 
+
4378  void
+
4379  init(jtx::Account const& acct)
+
4380  {
+
4381  accounts[acct].init(env, acct);
+
4382  }
+
4383 
+
4384  void
+
4385  receive(
+
4386  jtx::Account const& acct,
+
4387  STAmount amt,
+
4388  std::uint64_t divisor = 1)
+
4389  {
+
4390  if (amt.issue() != xrpIssue())
+
4391  return;
+
4392  auto it = accounts.find(acct);
+
4393  if (it == accounts.end())
+
4394  {
+
4395  accounts[acct].init(env, acct);
+
4396  // we just looked up the account, so expectedDiff == 0
+
4397  }
+
4398  else
+
4399  {
+
4400  it->second.expectedDiff +=
+
4401  (divisor == 1 ? amt
+
4402  : divide(
+
4403  amt,
+
4404  STAmount(amt.issue(), divisor),
+
4405  amt.issue()));
+
4406  }
+
4407  }
+
4408 
+
4409  void
+
4410  spend(jtx::Account const& acct, STAmount amt, std::uint64_t times = 1)
+
4411  {
+
4412  if (amt.issue() != xrpIssue())
+
4413  return;
+
4414  receive(
+
4415  acct,
+
4416  times == 1
+
4417  ? -amt
+
4418  : -multiply(
+
4419  amt, STAmount(amt.issue(), times), amt.issue()));
+
4420  }
+
4421 
+
4422  void
+
4423  transfer(jtx::Account const& from, jtx::Account const& to, STAmount amt)
+
4424  {
+
4425  spend(from, amt);
+
4426  receive(to, amt);
+
4427  }
+
4428 
+
4429  void
+
4430  spendFee(jtx::Account const& acct, size_t times = 1)
+
4431  {
+
4432  spend(acct, tx_fee, times);
+
4433  }
+
4434 
+
4435  bool
+
4436  verify() const
+
4437  {
+
4438  for (auto const& [acct, state] : accounts)
+
4439  if (!state.verify(env, acct))
+
4440  return false;
+
4441  return true;
+
4442  }
+
4443 
+
4444  struct BridgeCounters
+
4445  {
+
4446  using complete_cb =
+
4447  std::function<void(std::vector<size_t> const& signers)>;
+
4448 
+
4449  uint32_t claim_id{0};
+
4450  uint32_t create_count{0}; // for account create. First should be 1
+
4451  uint32_t claim_count{
+
4452  0}; // for account create. Increments after quorum for
+
4453  // current create_count (starts at 1) is reached.
+
4454 
+
4455  uint32_t num_create_attn_sent{0}; // for current claim_count
+
4456  std::vector<size_t> signers;
+
4457  std::vector<complete_cb> create_callbacks;
+
4458  };
+
4459 
+
4460  struct Claims
+
4461  {
+
4462  ClaimVec xfer_claims;
+
4463  CreateClaimMap create_claims;
+
4464  };
+
4465 
+
4466  using SignerAttns = std::unordered_map<BridgeID, Claims>;
+
4467  using SignersAttns = std::array<SignerAttns, num_signers>;
+
4468 
+
4469  ENV& env;
+
4470  std::map<jtx::Account, AccountStateTrack> accounts;
+
4471  SignersAttns signers_attns;
+
4472  std::map<BridgeID, BridgeCounters> counters;
+
4473  STAmount tx_fee;
+
4474  };
4475 
-
4476  void
-
4477  sendAttestations()
-
4478  {
-
4479  a_.sendAttestations();
-
4480  b_.sendAttestations();
-
4481  }
-
4482 
-
4483  void
-
4484  init(jtx::Account const& acct)
-
4485  {
-
4486  a_.init(acct);
-
4487  b_.init(acct);
-
4488  }
-
4489 
-
4490  ChainStateTrack a_;
-
4491  ChainStateTrack b_;
-
4492  };
-
4493 
-
4494  enum SmState {
-
4495  st_initial,
-
4496  st_claimid_created,
-
4497  st_attesting,
-
4498  st_attested,
-
4499  st_completed,
-
4500  st_closed,
-
4501  };
-
4502 
-
4503  enum Act_Flags { af_a2b = 1 << 0 };
-
4504 
-
4505  // --------------------------------------------------
-
4506  template <class T>
-
4507  class SmBase
-
4508  {
-
4509  public:
-
4510  SmBase(
-
4511  const std::shared_ptr<ChainStateTracker>& chainstate,
-
4512  const BridgeDef& bridge)
-
4513  : bridge_(bridge), st_(chainstate)
-
4514  {
-
4515  }
+
4476  struct ChainStateTracker
+
4477  {
+
4478  ChainStateTracker(ENV& a_env, ENV& b_env) : a_(a_env), b_(b_env)
+
4479  {
+
4480  }
+
4481 
+
4482  bool
+
4483  verify() const
+
4484  {
+
4485  return a_.verify() && b_.verify();
+
4486  }
+
4487 
+
4488  void
+
4489  sendAttestations()
+
4490  {
+
4491  a_.sendAttestations();
+
4492  b_.sendAttestations();
+
4493  }
+
4494 
+
4495  void
+
4496  init(jtx::Account const& acct)
+
4497  {
+
4498  a_.init(acct);
+
4499  b_.init(acct);
+
4500  }
+
4501 
+
4502  ChainStateTrack a_;
+
4503  ChainStateTrack b_;
+
4504  };
+
4505 
+
4506  enum SmState {
+
4507  st_initial,
+
4508  st_claimid_created,
+
4509  st_attesting,
+
4510  st_attested,
+
4511  st_completed,
+
4512  st_closed,
+
4513  };
+
4514 
+
4515  enum Act_Flags { af_a2b = 1 << 0 };
4516 
-
4517  ChainStateTrack&
-
4518  srcState()
-
4519  {
-
4520  return static_cast<T&>(*this).a2b() ? st_->a_ : st_->b_;
-
4521  }
-
4522 
-
4523  ChainStateTrack&
-
4524  destState()
-
4525  {
-
4526  return static_cast<T&>(*this).a2b() ? st_->b_ : st_->a_;
+
4517  // --------------------------------------------------
+
4518  template <class T>
+
4519  class SmBase
+
4520  {
+
4521  public:
+
4522  SmBase(
+
4523  const std::shared_ptr<ChainStateTracker>& chainstate,
+
4524  const BridgeDef& bridge)
+
4525  : bridge_(bridge), st_(chainstate)
+
4526  {
4527  }
4528 
-
4529  jtx::Account const&
-
4530  srcDoor()
+
4529  ChainStateTrack&
+
4530  srcState()
4531  {
-
4532  return static_cast<T&>(*this).a2b() ? bridge_.doorA : bridge_.doorB;
+
4532  return static_cast<T&>(*this).a2b() ? st_->a_ : st_->b_;
4533  }
4534 
-
4535  jtx::Account const&
-
4536  dstDoor()
+
4535  ChainStateTrack&
+
4536  destState()
4537  {
-
4538  return static_cast<T&>(*this).a2b() ? bridge_.doorB : bridge_.doorA;
+
4538  return static_cast<T&>(*this).a2b() ? st_->b_ : st_->a_;
4539  }
4540 
-
4541  protected:
-
4542  const BridgeDef& bridge_;
-
4543  std::shared_ptr<ChainStateTracker> st_;
-
4544  };
-
4545 
-
4546  // --------------------------------------------------
-
4547  class SmCreateAccount : public SmBase<SmCreateAccount>
-
4548  {
-
4549  public:
-
4550  using Base = SmBase<SmCreateAccount>;
-
4551 
-
4552  SmCreateAccount(
-
4553  const std::shared_ptr<ChainStateTracker>& chainstate,
-
4554  const BridgeDef& bridge,
-
4555  AccountCreate create)
-
4556  : Base(chainstate, bridge)
-
4557  , sm_state(st_initial)
-
4558  , cr(std::move(create))
-
4559  {
-
4560  }
-
4561 
-
4562  bool
-
4563  a2b() const
-
4564  {
-
4565  return cr.a2b;
-
4566  }
-
4567 
-
4568  uint32_t
-
4569  issue_account_create()
-
4570  {
-
4571  ChainStateTrack& st = srcState();
-
4572  jtx::Account const& srcdoor = srcDoor();
+
4541  jtx::Account const&
+
4542  srcDoor()
+
4543  {
+
4544  return static_cast<T&>(*this).a2b() ? bridge_.doorA : bridge_.doorB;
+
4545  }
+
4546 
+
4547  jtx::Account const&
+
4548  dstDoor()
+
4549  {
+
4550  return static_cast<T&>(*this).a2b() ? bridge_.doorB : bridge_.doorA;
+
4551  }
+
4552 
+
4553  protected:
+
4554  const BridgeDef& bridge_;
+
4555  std::shared_ptr<ChainStateTracker> st_;
+
4556  };
+
4557 
+
4558  // --------------------------------------------------
+
4559  class SmCreateAccount : public SmBase<SmCreateAccount>
+
4560  {
+
4561  public:
+
4562  using Base = SmBase<SmCreateAccount>;
+
4563 
+
4564  SmCreateAccount(
+
4565  const std::shared_ptr<ChainStateTracker>& chainstate,
+
4566  const BridgeDef& bridge,
+
4567  AccountCreate create)
+
4568  : Base(chainstate, bridge)
+
4569  , sm_state(st_initial)
+
4570  , cr(std::move(create))
+
4571  {
+
4572  }
4573 
-
4574  st.env
-
4575  .tx(sidechain_xchain_account_create(
-
4576  cr.from, bridge_.jvb, cr.to, cr.amt, cr.reward))
-
4577  .close(); // needed for claim_id sequence to be correct'
-
4578  st.spendFee(cr.from);
-
4579  st.transfer(cr.from, srcdoor, cr.amt);
-
4580  st.transfer(cr.from, srcdoor, cr.reward);
-
4581 
-
4582  return ++st.counters[&bridge_].create_count;
-
4583  }
-
4584 
-
4585  void
-
4586  attest(uint64_t time, uint32_t rnd)
-
4587  {
-
4588  ChainStateTrack& st = destState();
-
4589 
-
4590  // check all signers, but start at a random one
-
4591  size_t i;
-
4592  for (i = 0; i < num_signers; ++i)
-
4593  {
-
4594  size_t signer_idx = (rnd + i) % num_signers;
-
4595 
-
4596  if (!(cr.attested[signer_idx]))
-
4597  {
-
4598  // enqueue one attestation for this signer
-
4599  cr.attested[signer_idx] = true;
-
4600 
-
4601  st.signers_attns[signer_idx][&bridge_]
-
4602  .create_claims[cr.claim_id - 1]
-
4603  .emplace_back(create_account_attestation(
-
4604  bridge_.signers[signer_idx].account,
-
4605  bridge_.jvb,
-
4606  cr.from,
-
4607  cr.amt,
-
4608  cr.reward,
-
4609  bridge_.signers[signer_idx].account,
-
4610  cr.a2b,
-
4611  cr.claim_id,
-
4612  cr.to,
-
4613  bridge_.signers[signer_idx]));
-
4614  break;
-
4615  }
-
4616  }
-
4617 
-
4618  if (i == num_signers)
-
4619  return; // did not attest
-
4620 
-
4621  auto& counters = st.counters[&bridge_];
-
4622  if (counters.create_callbacks.size() < cr.claim_id)
-
4623  counters.create_callbacks.resize(cr.claim_id);
-
4624 
-
4625  auto complete_cb = [&](std::vector<size_t> const& signers) {
-
4626  auto num_attestors = signers.size();
-
4627  st.env.close();
-
4628  assert(
-
4629  num_attestors <=
-
4630  std::count(cr.attested.begin(), cr.attested.end(), true));
-
4631  assert(num_attestors >= bridge_.quorum);
-
4632  assert(cr.claim_id - 1 == counters.claim_count);
-
4633 
-
4634  auto r = cr.reward;
-
4635  auto reward = divide(r, STAmount(num_attestors), r.issue());
+
4574  bool
+
4575  a2b() const
+
4576  {
+
4577  return cr.a2b;
+
4578  }
+
4579 
+
4580  uint32_t
+
4581  issue_account_create()
+
4582  {
+
4583  ChainStateTrack& st = srcState();
+
4584  jtx::Account const& srcdoor = srcDoor();
+
4585 
+
4586  st.env
+
4587  .tx(sidechain_xchain_account_create(
+
4588  cr.from, bridge_.jvb, cr.to, cr.amt, cr.reward))
+
4589  .close(); // needed for claim_id sequence to be correct'
+
4590  st.spendFee(cr.from);
+
4591  st.transfer(cr.from, srcdoor, cr.amt);
+
4592  st.transfer(cr.from, srcdoor, cr.reward);
+
4593 
+
4594  return ++st.counters[&bridge_].create_count;
+
4595  }
+
4596 
+
4597  void
+
4598  attest(uint64_t time, uint32_t rnd)
+
4599  {
+
4600  ChainStateTrack& st = destState();
+
4601 
+
4602  // check all signers, but start at a random one
+
4603  size_t i;
+
4604  for (i = 0; i < num_signers; ++i)
+
4605  {
+
4606  size_t signer_idx = (rnd + i) % num_signers;
+
4607 
+
4608  if (!(cr.attested[signer_idx]))
+
4609  {
+
4610  // enqueue one attestation for this signer
+
4611  cr.attested[signer_idx] = true;
+
4612 
+
4613  st.signers_attns[signer_idx][&bridge_]
+
4614  .create_claims[cr.claim_id - 1]
+
4615  .emplace_back(create_account_attestation(
+
4616  bridge_.signers[signer_idx].account,
+
4617  bridge_.jvb,
+
4618  cr.from,
+
4619  cr.amt,
+
4620  cr.reward,
+
4621  bridge_.signers[signer_idx].account,
+
4622  cr.a2b,
+
4623  cr.claim_id,
+
4624  cr.to,
+
4625  bridge_.signers[signer_idx]));
+
4626  break;
+
4627  }
+
4628  }
+
4629 
+
4630  if (i == num_signers)
+
4631  return; // did not attest
+
4632 
+
4633  auto& counters = st.counters[&bridge_];
+
4634  if (counters.create_callbacks.size() < cr.claim_id)
+
4635  counters.create_callbacks.resize(cr.claim_id);
4636 
-
4637  for (auto i : signers)
-
4638  st.receive(bridge_.signers[i].account, reward);
-
4639 
-
4640  st.spend(dstDoor(), reward, num_attestors);
-
4641  st.transfer(dstDoor(), cr.to, cr.amt);
-
4642  st.env.env_.memoize(cr.to);
-
4643  sm_state = st_completed;
-
4644  };
+
4637  auto complete_cb = [&](std::vector<size_t> const& signers) {
+
4638  auto num_attestors = signers.size();
+
4639  st.env.close();
+
4640  assert(
+
4641  num_attestors <=
+
4642  std::count(cr.attested.begin(), cr.attested.end(), true));
+
4643  assert(num_attestors >= bridge_.quorum);
+
4644  assert(cr.claim_id - 1 == counters.claim_count);
4645 
-
4646  counters.create_callbacks[cr.claim_id - 1] = std::move(complete_cb);
-
4647  }
+
4646  auto r = cr.reward;
+
4647  auto reward = divide(r, STAmount(num_attestors), r.issue());
4648 
-
4649  SmState
-
4650  advance(uint64_t time, uint32_t rnd)
-
4651  {
-
4652  switch (sm_state)
-
4653  {
-
4654  case st_initial:
-
4655  cr.claim_id = issue_account_create();
-
4656  sm_state = st_attesting;
-
4657  break;
-
4658 
-
4659  case st_attesting:
-
4660  attest(time, rnd);
-
4661  break;
-
4662 
-
4663  default:
-
4664  assert(0);
-
4665  break;
-
4666 
-
4667  case st_completed:
-
4668  break; // will get this once
-
4669  }
-
4670  return sm_state;
-
4671  }
-
4672 
-
4673  private:
-
4674  SmState sm_state;
-
4675  AccountCreate cr;
-
4676  };
-
4677 
-
4678  // --------------------------------------------------
-
4679  class SmTransfer : public SmBase<SmTransfer>
-
4680  {
-
4681  public:
-
4682  using Base = SmBase<SmTransfer>;
-
4683 
-
4684  SmTransfer(
-
4685  const std::shared_ptr<ChainStateTracker>& chainstate,
-
4686  const BridgeDef& bridge,
-
4687  Transfer xfer)
-
4688  : Base(chainstate, bridge)
-
4689  , xfer(std::move(xfer))
-
4690  , sm_state(st_initial)
-
4691  {
-
4692  }
-
4693 
-
4694  bool
-
4695  a2b() const
-
4696  {
-
4697  return xfer.a2b;
-
4698  }
-
4699 
-
4700  uint32_t
-
4701  create_claim_id()
-
4702  {
-
4703  ChainStateTrack& st = destState();
-
4704 
-
4705  st.env
-
4706  .tx(xchain_create_claim_id(
-
4707  xfer.to, bridge_.jvb, bridge_.reward, xfer.from))
-
4708  .close(); // needed for claim_id sequence to be
-
4709  // correct'
-
4710  st.spendFee(xfer.to);
-
4711  return ++st.counters[&bridge_].claim_id;
-
4712  }
-
4713 
-
4714  void
-
4715  commit()
-
4716  {
-
4717  ChainStateTrack& st = srcState();
-
4718  jtx::Account const& srcdoor = srcDoor();
-
4719 
-
4720  if (xfer.amt.issue() != xrpIssue())
-
4721  {
-
4722  st.env.tx(pay(srcdoor, xfer.from, xfer.amt));
-
4723  st.spendFee(srcdoor);
-
4724  }
-
4725  st.env.tx(xchain_commit(
-
4726  xfer.from,
-
4727  bridge_.jvb,
-
4728  xfer.claim_id,
-
4729  xfer.amt,
-
4730  xfer.with_claim == WithClaim::yes
-
4731  ? std::nullopt
-
4732  : std::optional<jtx::Account>(xfer.finaldest)));
-
4733  st.spendFee(xfer.from);
-
4734  st.transfer(xfer.from, srcdoor, xfer.amt);
-
4735  }
-
4736 
-
4737  void
-
4738  distribute_reward(ChainStateTrack& st)
-
4739  {
-
4740  auto r = bridge_.reward;
-
4741  auto reward = divide(r, STAmount(bridge_.quorum), r.issue());
-
4742 
-
4743  for (size_t i = 0; i < num_signers; ++i)
-
4744  {
-
4745  if (xfer.attested[i])
-
4746  st.receive(bridge_.signers[i].account, reward);
-
4747  }
-
4748  st.spend(xfer.to, reward, bridge_.quorum);
-
4749  }
-
4750 
-
4751  bool
-
4752  attest(uint64_t time, uint32_t rnd)
-
4753  {
-
4754  ChainStateTrack& st = destState();
-
4755 
-
4756  // check all signers, but start at a random one
-
4757  for (size_t i = 0; i < num_signers; ++i)
-
4758  {
-
4759  size_t signer_idx = (rnd + i) % num_signers;
-
4760  if (!(xfer.attested[signer_idx]))
-
4761  {
-
4762  // enqueue one attestation for this signer
-
4763  xfer.attested[signer_idx] = true;
-
4764 
-
4765  st.signers_attns[signer_idx][&bridge_]
-
4766  .xfer_claims.emplace_back(claim_attestation(
-
4767  bridge_.signers[signer_idx].account,
-
4768  bridge_.jvb,
-
4769  xfer.from,
-
4770  xfer.amt,
-
4771  bridge_.signers[signer_idx].account,
-
4772  xfer.a2b,
-
4773  xfer.claim_id,
-
4774  xfer.with_claim == WithClaim::yes
-
4775  ? std::nullopt
-
4776  : std::optional<jtx::Account>(xfer.finaldest),
-
4777  bridge_.signers[signer_idx]));
-
4778  break;
-
4779  }
-
4780  }
-
4781 
-
4782  // return true if quorum was reached, false otherwise
-
4783  bool quorum =
-
4784  std::count(xfer.attested.begin(), xfer.attested.end(), true) >=
-
4785  bridge_.quorum;
-
4786  if (quorum && xfer.with_claim == WithClaim::no)
-
4787  {
-
4788  distribute_reward(st);
-
4789  st.transfer(dstDoor(), xfer.finaldest, xfer.amt);
-
4790  }
-
4791  return quorum;
-
4792  }
+
4649  for (auto i : signers)
+
4650  st.receive(bridge_.signers[i].account, reward);
+
4651 
+
4652  st.spend(dstDoor(), reward, num_attestors);
+
4653  st.transfer(dstDoor(), cr.to, cr.amt);
+
4654  st.env.env_.memoize(cr.to);
+
4655  sm_state = st_completed;
+
4656  };
+
4657 
+
4658  counters.create_callbacks[cr.claim_id - 1] = std::move(complete_cb);
+
4659  }
+
4660 
+
4661  SmState
+
4662  advance(uint64_t time, uint32_t rnd)
+
4663  {
+
4664  switch (sm_state)
+
4665  {
+
4666  case st_initial:
+
4667  cr.claim_id = issue_account_create();
+
4668  sm_state = st_attesting;
+
4669  break;
+
4670 
+
4671  case st_attesting:
+
4672  attest(time, rnd);
+
4673  break;
+
4674 
+
4675  default:
+
4676  assert(0);
+
4677  break;
+
4678 
+
4679  case st_completed:
+
4680  break; // will get this once
+
4681  }
+
4682  return sm_state;
+
4683  }
+
4684 
+
4685  private:
+
4686  SmState sm_state;
+
4687  AccountCreate cr;
+
4688  };
+
4689 
+
4690  // --------------------------------------------------
+
4691  class SmTransfer : public SmBase<SmTransfer>
+
4692  {
+
4693  public:
+
4694  using Base = SmBase<SmTransfer>;
+
4695 
+
4696  SmTransfer(
+
4697  const std::shared_ptr<ChainStateTracker>& chainstate,
+
4698  const BridgeDef& bridge,
+
4699  Transfer xfer)
+
4700  : Base(chainstate, bridge)
+
4701  , xfer(std::move(xfer))
+
4702  , sm_state(st_initial)
+
4703  {
+
4704  }
+
4705 
+
4706  bool
+
4707  a2b() const
+
4708  {
+
4709  return xfer.a2b;
+
4710  }
+
4711 
+
4712  uint32_t
+
4713  create_claim_id()
+
4714  {
+
4715  ChainStateTrack& st = destState();
+
4716 
+
4717  st.env
+
4718  .tx(xchain_create_claim_id(
+
4719  xfer.to, bridge_.jvb, bridge_.reward, xfer.from))
+
4720  .close(); // needed for claim_id sequence to be
+
4721  // correct'
+
4722  st.spendFee(xfer.to);
+
4723  return ++st.counters[&bridge_].claim_id;
+
4724  }
+
4725 
+
4726  void
+
4727  commit()
+
4728  {
+
4729  ChainStateTrack& st = srcState();
+
4730  jtx::Account const& srcdoor = srcDoor();
+
4731 
+
4732  if (xfer.amt.issue() != xrpIssue())
+
4733  {
+
4734  st.env.tx(pay(srcdoor, xfer.from, xfer.amt));
+
4735  st.spendFee(srcdoor);
+
4736  }
+
4737  st.env.tx(xchain_commit(
+
4738  xfer.from,
+
4739  bridge_.jvb,
+
4740  xfer.claim_id,
+
4741  xfer.amt,
+
4742  xfer.with_claim == WithClaim::yes
+
4743  ? std::nullopt
+
4744  : std::optional<jtx::Account>(xfer.finaldest)));
+
4745  st.spendFee(xfer.from);
+
4746  st.transfer(xfer.from, srcdoor, xfer.amt);
+
4747  }
+
4748 
+
4749  void
+
4750  distribute_reward(ChainStateTrack& st)
+
4751  {
+
4752  auto r = bridge_.reward;
+
4753  auto reward = divide(r, STAmount(bridge_.quorum), r.issue());
+
4754 
+
4755  for (size_t i = 0; i < num_signers; ++i)
+
4756  {
+
4757  if (xfer.attested[i])
+
4758  st.receive(bridge_.signers[i].account, reward);
+
4759  }
+
4760  st.spend(xfer.to, reward, bridge_.quorum);
+
4761  }
+
4762 
+
4763  bool
+
4764  attest(uint64_t time, uint32_t rnd)
+
4765  {
+
4766  ChainStateTrack& st = destState();
+
4767 
+
4768  // check all signers, but start at a random one
+
4769  for (size_t i = 0; i < num_signers; ++i)
+
4770  {
+
4771  size_t signer_idx = (rnd + i) % num_signers;
+
4772  if (!(xfer.attested[signer_idx]))
+
4773  {
+
4774  // enqueue one attestation for this signer
+
4775  xfer.attested[signer_idx] = true;
+
4776 
+
4777  st.signers_attns[signer_idx][&bridge_]
+
4778  .xfer_claims.emplace_back(claim_attestation(
+
4779  bridge_.signers[signer_idx].account,
+
4780  bridge_.jvb,
+
4781  xfer.from,
+
4782  xfer.amt,
+
4783  bridge_.signers[signer_idx].account,
+
4784  xfer.a2b,
+
4785  xfer.claim_id,
+
4786  xfer.with_claim == WithClaim::yes
+
4787  ? std::nullopt
+
4788  : std::optional<jtx::Account>(xfer.finaldest),
+
4789  bridge_.signers[signer_idx]));
+
4790  break;
+
4791  }
+
4792  }
4793 
-
4794  void
-
4795  claim()
-
4796  {
-
4797  ChainStateTrack& st = destState();
-
4798  st.env.tx(xchain_claim(
-
4799  xfer.to, bridge_.jvb, xfer.claim_id, xfer.amt, xfer.finaldest));
-
4800  distribute_reward(st);
-
4801  st.transfer(dstDoor(), xfer.finaldest, xfer.amt);
-
4802  st.spendFee(xfer.to);
-
4803  }
-
4804 
-
4805  SmState
-
4806  advance(uint64_t time, uint32_t rnd)
-
4807  {
-
4808  switch (sm_state)
-
4809  {
-
4810  case st_initial:
-
4811  xfer.claim_id = create_claim_id();
-
4812  sm_state = st_claimid_created;
-
4813  break;
-
4814 
-
4815  case st_claimid_created:
-
4816  commit();
-
4817  sm_state = st_attesting;
-
4818  break;
-
4819 
-
4820  case st_attesting:
-
4821  sm_state = attest(time, rnd)
-
4822  ? (xfer.with_claim == WithClaim::yes ? st_attested
-
4823  : st_completed)
-
4824  : st_attesting;
+
4794  // return true if quorum was reached, false otherwise
+
4795  bool quorum =
+
4796  std::count(xfer.attested.begin(), xfer.attested.end(), true) >=
+
4797  bridge_.quorum;
+
4798  if (quorum && xfer.with_claim == WithClaim::no)
+
4799  {
+
4800  distribute_reward(st);
+
4801  st.transfer(dstDoor(), xfer.finaldest, xfer.amt);
+
4802  }
+
4803  return quorum;
+
4804  }
+
4805 
+
4806  void
+
4807  claim()
+
4808  {
+
4809  ChainStateTrack& st = destState();
+
4810  st.env.tx(xchain_claim(
+
4811  xfer.to, bridge_.jvb, xfer.claim_id, xfer.amt, xfer.finaldest));
+
4812  distribute_reward(st);
+
4813  st.transfer(dstDoor(), xfer.finaldest, xfer.amt);
+
4814  st.spendFee(xfer.to);
+
4815  }
+
4816 
+
4817  SmState
+
4818  advance(uint64_t time, uint32_t rnd)
+
4819  {
+
4820  switch (sm_state)
+
4821  {
+
4822  case st_initial:
+
4823  xfer.claim_id = create_claim_id();
+
4824  sm_state = st_claimid_created;
4825  break;
4826 
-
4827  case st_attested:
-
4828  assert(xfer.with_claim == WithClaim::yes);
-
4829  claim();
-
4830  sm_state = st_completed;
-
4831  break;
-
4832 
-
4833  default:
-
4834  case st_completed:
-
4835  assert(0); // should have been removed
-
4836  break;
-
4837  }
-
4838  return sm_state;
-
4839  }
-
4840 
-
4841  private:
-
4842  Transfer xfer;
-
4843  SmState sm_state;
-
4844  };
-
4845 
-
4846  // --------------------------------------------------
-
4847  using Sm = std::variant<SmCreateAccount, SmTransfer>;
-
4848  using SmCont = std::list<std::pair<uint64_t, Sm>>;
-
4849 
-
4850  SmCont sm_;
-
4851 
-
4852  void
-
4853  xfer(
-
4854  uint64_t time,
-
4855  const std::shared_ptr<ChainStateTracker>& chainstate,
-
4856  BridgeDef const& bridge,
-
4857  Transfer transfer)
-
4858  {
-
4859  sm_.emplace_back(
-
4860  time, SmTransfer(chainstate, bridge, std::move(transfer)));
-
4861  }
-
4862 
-
4863  void
-
4864  ac(uint64_t time,
-
4865  const std::shared_ptr<ChainStateTracker>& chainstate,
-
4866  BridgeDef const& bridge,
-
4867  AccountCreate ac)
-
4868  {
-
4869  sm_.emplace_back(
-
4870  time, SmCreateAccount(chainstate, bridge, std::move(ac)));
-
4871  }
-
4872 
-
4873 public:
-
4874  void
-
4875  runSimulation(
-
4876  std::shared_ptr<ChainStateTracker> const& st,
-
4877  bool verify_balances = true)
-
4878  {
-
4879  using namespace jtx;
-
4880  uint64_t time = 0;
-
4881  std::mt19937 gen(27); // Standard mersenne_twister_engine
-
4882  std::uniform_int_distribution<uint32_t> distrib(0, 9);
-
4883 
-
4884  while (!sm_.empty())
-
4885  {
-
4886  ++time;
-
4887  for (auto it = sm_.begin(); it != sm_.end();)
-
4888  {
-
4889  auto vis = [&](auto& sm) {
-
4890  uint32_t rnd = distrib(gen);
-
4891  return sm.advance(time, rnd);
-
4892  };
-
4893  auto& [t, sm] = *it;
-
4894  if (t <= time && std::visit(vis, sm) == st_completed)
-
4895  it = sm_.erase(it);
-
4896  else
-
4897  ++it;
-
4898  }
-
4899 
-
4900  // send attestations
-
4901  st->sendAttestations();
-
4902 
-
4903  // make sure all transactions have been applied
-
4904  st->a_.env.close();
-
4905  st->b_.env.close();
-
4906 
-
4907  if (verify_balances)
-
4908  {
-
4909  BEAST_EXPECT(st->verify());
+
4827  case st_claimid_created:
+
4828  commit();
+
4829  sm_state = st_attesting;
+
4830  break;
+
4831 
+
4832  case st_attesting:
+
4833  sm_state = attest(time, rnd)
+
4834  ? (xfer.with_claim == WithClaim::yes ? st_attested
+
4835  : st_completed)
+
4836  : st_attesting;
+
4837  break;
+
4838 
+
4839  case st_attested:
+
4840  assert(xfer.with_claim == WithClaim::yes);
+
4841  claim();
+
4842  sm_state = st_completed;
+
4843  break;
+
4844 
+
4845  default:
+
4846  case st_completed:
+
4847  assert(0); // should have been removed
+
4848  break;
+
4849  }
+
4850  return sm_state;
+
4851  }
+
4852 
+
4853  private:
+
4854  Transfer xfer;
+
4855  SmState sm_state;
+
4856  };
+
4857 
+
4858  // --------------------------------------------------
+
4859  using Sm = std::variant<SmCreateAccount, SmTransfer>;
+
4860  using SmCont = std::list<std::pair<uint64_t, Sm>>;
+
4861 
+
4862  SmCont sm_;
+
4863 
+
4864  void
+
4865  xfer(
+
4866  uint64_t time,
+
4867  const std::shared_ptr<ChainStateTracker>& chainstate,
+
4868  BridgeDef const& bridge,
+
4869  Transfer transfer)
+
4870  {
+
4871  sm_.emplace_back(
+
4872  time, SmTransfer(chainstate, bridge, std::move(transfer)));
+
4873  }
+
4874 
+
4875  void
+
4876  ac(uint64_t time,
+
4877  const std::shared_ptr<ChainStateTracker>& chainstate,
+
4878  BridgeDef const& bridge,
+
4879  AccountCreate ac)
+
4880  {
+
4881  sm_.emplace_back(
+
4882  time, SmCreateAccount(chainstate, bridge, std::move(ac)));
+
4883  }
+
4884 
+
4885 public:
+
4886  void
+
4887  runSimulation(
+
4888  std::shared_ptr<ChainStateTracker> const& st,
+
4889  bool verify_balances = true)
+
4890  {
+
4891  using namespace jtx;
+
4892  uint64_t time = 0;
+
4893  std::mt19937 gen(27); // Standard mersenne_twister_engine
+
4894  std::uniform_int_distribution<uint32_t> distrib(0, 9);
+
4895 
+
4896  while (!sm_.empty())
+
4897  {
+
4898  ++time;
+
4899  for (auto it = sm_.begin(); it != sm_.end();)
+
4900  {
+
4901  auto vis = [&](auto& sm) {
+
4902  uint32_t rnd = distrib(gen);
+
4903  return sm.advance(time, rnd);
+
4904  };
+
4905  auto& [t, sm] = *it;
+
4906  if (t <= time && std::visit(vis, sm) == st_completed)
+
4907  it = sm_.erase(it);
+
4908  else
+
4909  ++it;
4910  }
-
4911  }
-
4912  }
-
4913 
-
4914  void
-
4915  testXChainSimulation()
-
4916  {
-
4917  using namespace jtx;
+
4911 
+
4912  // send attestations
+
4913  st->sendAttestations();
+
4914 
+
4915  // make sure all transactions have been applied
+
4916  st->a_.env.close();
+
4917  st->b_.env.close();
4918 
-
4919  testcase("Bridge usage simulation");
-
4920 
-
4921  XEnv mcEnv(*this);
-
4922  XEnv scEnv(*this, true);
-
4923 
-
4924  auto st = std::make_shared<ChainStateTracker>(mcEnv, scEnv);
+
4919  if (verify_balances)
+
4920  {
+
4921  BEAST_EXPECT(st->verify());
+
4922  }
+
4923  }
+
4924  }
4925 
-
4926  // create 10 accounts + door funded on both chains, and store
-
4927  // in ChainStateTracker the initial amount of these accounts
-
4928  Account doorXRPLocking, doorUSDLocking, doorUSDIssuing;
-
4929 
-
4930  constexpr size_t num_acct = 10;
-
4931  auto a = [&doorXRPLocking, &doorUSDLocking, &doorUSDIssuing]() {
-
4932  using namespace std::literals;
-
4933  std::vector<Account> result;
-
4934  result.reserve(num_acct);
-
4935  for (int i = 0; i < num_acct; ++i)
-
4936  result.emplace_back(
-
4937  "a"s + std::to_string(i),
-
4938  (i % 2) ? KeyType::ed25519 : KeyType::secp256k1);
-
4939  result.emplace_back("doorXRPLocking");
-
4940  doorXRPLocking = result.back();
-
4941  result.emplace_back("doorUSDLocking");
-
4942  doorUSDLocking = result.back();
-
4943  result.emplace_back("doorUSDIssuing");
-
4944  doorUSDIssuing = result.back();
-
4945  return result;
-
4946  }();
-
4947 
-
4948  for (auto& acct : a)
-
4949  {
-
4950  STAmount amt{XRP(100000)};
-
4951 
-
4952  mcEnv.fund(amt, acct);
-
4953  scEnv.fund(amt, acct);
-
4954  }
-
4955  Account USDLocking{"USDLocking"};
-
4956  IOU usdLocking{USDLocking["USD"]};
-
4957  IOU usdIssuing{doorUSDIssuing["USD"]};
-
4958 
-
4959  mcEnv.fund(XRP(100000), USDLocking);
-
4960  mcEnv.close();
-
4961  mcEnv.tx(trust(doorUSDLocking, usdLocking(100000)));
-
4962  mcEnv.close();
-
4963  mcEnv.tx(pay(USDLocking, doorUSDLocking, usdLocking(50000)));
-
4964 
-
4965  for (int i = 0; i < a.size(); ++i)
-
4966  {
-
4967  auto& acct{a[i]};
-
4968  if (i < num_acct)
-
4969  {
-
4970  mcEnv.tx(trust(acct, usdLocking(100000)));
-
4971  scEnv.tx(trust(acct, usdIssuing(100000)));
-
4972  }
-
4973  st->init(acct);
-
4974  }
-
4975  for (auto& s : signers)
-
4976  st->init(s.account);
-
4977 
-
4978  st->b_.init(Account::master);
-
4979 
-
4980  // also create some unfunded accounts
-
4981  constexpr size_t num_ua = 20;
-
4982  auto ua = []() {
-
4983  using namespace std::literals;
-
4984  std::vector<Account> result;
-
4985  result.reserve(num_ua);
-
4986  for (int i = 0; i < num_ua; ++i)
-
4987  result.emplace_back(
-
4988  "ua"s + std::to_string(i),
-
4989  (i % 2) ? KeyType::ed25519 : KeyType::secp256k1);
-
4990  return result;
-
4991  }();
-
4992 
-
4993  // initialize a bridge from a BridgeDef
-
4994  auto initBridge = [&mcEnv, &scEnv, &st](BridgeDef& bd) {
-
4995  bd.initBridge(mcEnv, scEnv);
-
4996  st->a_.spendFee(bd.doorA, 2);
-
4997  st->b_.spendFee(bd.doorB, 2);
-
4998  };
-
4999 
-
5000  // create XRP -> XRP bridge
-
5001  // ------------------------
-
5002  BridgeDef xrp_b{
-
5003  doorXRPLocking,
-
5004  xrpIssue(),
-
5005  Account::master,
-
5006  xrpIssue(),
-
5007  XRP(1),
-
5008  XRP(20),
-
5009  quorum,
-
5010  signers,
-
5011  Json::nullValue};
-
5012 
-
5013  initBridge(xrp_b);
-
5014 
-
5015  // create USD -> USD bridge
-
5016  // ------------------------
-
5017  BridgeDef usd_b{
-
5018  doorUSDLocking,
-
5019  usdLocking,
-
5020  doorUSDIssuing,
-
5021  usdIssuing,
-
5022  XRP(1),
-
5023  XRP(20),
-
5024  quorum,
-
5025  signers,
-
5026  Json::nullValue};
-
5027 
-
5028  initBridge(usd_b);
-
5029 
-
5030  // try a single account create + transfer to validate the simulation
-
5031  // engine. Do the transfer 8 time steps after the account create, to
-
5032  // give time enough for ua[0] to be funded now so it can reserve
-
5033  // the claimID
-
5034  // -----------------------------------------------------------------
-
5035  ac(0, st, xrp_b, {a[0], ua[0], XRP(777), xrp_b.reward, true});
-
5036  xfer(8, st, xrp_b, {a[0], ua[0], a[2], XRP(3), true});
-
5037  runSimulation(st);
-
5038 
-
5039  // try the same thing in the other direction
-
5040  // -----------------------------------------
-
5041  ac(0, st, xrp_b, {a[0], ua[0], XRP(777), xrp_b.reward, false});
-
5042  xfer(8, st, xrp_b, {a[0], ua[0], a[2], XRP(3), false});
-
5043  runSimulation(st);
-
5044 
-
5045  // run multiple XRP transfers
-
5046  // --------------------------
-
5047  xfer(0, st, xrp_b, {a[0], a[0], a[1], XRP(6), true, WithClaim::no});
-
5048  xfer(1, st, xrp_b, {a[0], a[0], a[1], XRP(8), false, WithClaim::no});
-
5049  xfer(1, st, xrp_b, {a[1], a[1], a[1], XRP(1), true});
-
5050  xfer(2, st, xrp_b, {a[0], a[0], a[1], XRP(3), false});
-
5051  xfer(2, st, xrp_b, {a[1], a[1], a[1], XRP(5), false});
-
5052  xfer(2, st, xrp_b, {a[0], a[0], a[1], XRP(7), false, WithClaim::no});
-
5053  xfer(2, st, xrp_b, {a[1], a[1], a[1], XRP(9), true});
-
5054  runSimulation(st);
-
5055 
-
5056  // run one USD transfer
-
5057  // --------------------
-
5058  xfer(0, st, usd_b, {a[0], a[1], a[2], usdLocking(3), true});
-
5059  runSimulation(st);
-
5060 
-
5061  // run multiple USD transfers
-
5062  // --------------------------
-
5063  xfer(0, st, usd_b, {a[0], a[0], a[1], usdLocking(6), true});
-
5064  xfer(1, st, usd_b, {a[0], a[0], a[1], usdIssuing(8), false});
-
5065  xfer(1, st, usd_b, {a[1], a[1], a[1], usdLocking(1), true});
-
5066  xfer(2, st, usd_b, {a[0], a[0], a[1], usdIssuing(3), false});
-
5067  xfer(2, st, usd_b, {a[1], a[1], a[1], usdIssuing(5), false});
-
5068  xfer(2, st, usd_b, {a[0], a[0], a[1], usdIssuing(7), false});
-
5069  xfer(2, st, usd_b, {a[1], a[1], a[1], usdLocking(9), true});
-
5070  runSimulation(st);
-
5071 
-
5072  // run mixed transfers
-
5073  // -------------------
-
5074  xfer(0, st, xrp_b, {a[0], a[0], a[0], XRP(1), true});
-
5075  xfer(0, st, usd_b, {a[1], a[3], a[3], usdIssuing(3), false});
-
5076  xfer(0, st, usd_b, {a[3], a[2], a[1], usdIssuing(5), false});
-
5077 
-
5078  xfer(1, st, xrp_b, {a[0], a[0], a[0], XRP(4), false});
-
5079  xfer(1, st, xrp_b, {a[1], a[1], a[0], XRP(8), true});
-
5080  xfer(1, st, usd_b, {a[4], a[1], a[1], usdLocking(7), true});
-
5081 
-
5082  xfer(3, st, xrp_b, {a[1], a[1], a[0], XRP(7), true});
-
5083  xfer(3, st, xrp_b, {a[0], a[4], a[3], XRP(2), false});
-
5084  xfer(3, st, xrp_b, {a[1], a[1], a[0], XRP(9), true});
-
5085  xfer(3, st, usd_b, {a[3], a[1], a[1], usdIssuing(11), false});
-
5086  runSimulation(st);
-
5087 
-
5088  // run multiple account create to stress attestation batching
-
5089  // ----------------------------------------------------------
-
5090  ac(0, st, xrp_b, {a[0], ua[1], XRP(301), xrp_b.reward, true});
-
5091  ac(0, st, xrp_b, {a[1], ua[2], XRP(302), xrp_b.reward, true});
-
5092  ac(1, st, xrp_b, {a[0], ua[3], XRP(303), xrp_b.reward, true});
-
5093  ac(2, st, xrp_b, {a[1], ua[4], XRP(304), xrp_b.reward, true});
-
5094  ac(3, st, xrp_b, {a[0], ua[5], XRP(305), xrp_b.reward, true});
-
5095  ac(4, st, xrp_b, {a[1], ua[6], XRP(306), xrp_b.reward, true});
-
5096  ac(6, st, xrp_b, {a[0], ua[7], XRP(307), xrp_b.reward, true});
-
5097  ac(7, st, xrp_b, {a[2], ua[8], XRP(308), xrp_b.reward, true});
-
5098  ac(9, st, xrp_b, {a[0], ua[9], XRP(309), xrp_b.reward, true});
-
5099  ac(9, st, xrp_b, {a[0], ua[9], XRP(309), xrp_b.reward, true});
-
5100  ac(10, st, xrp_b, {a[0], ua[10], XRP(310), xrp_b.reward, true});
-
5101  ac(12, st, xrp_b, {a[0], ua[11], XRP(311), xrp_b.reward, true});
-
5102  ac(12, st, xrp_b, {a[3], ua[12], XRP(312), xrp_b.reward, true});
-
5103  ac(12, st, xrp_b, {a[4], ua[13], XRP(313), xrp_b.reward, true});
-
5104  ac(12, st, xrp_b, {a[3], ua[14], XRP(314), xrp_b.reward, true});
-
5105  ac(12, st, xrp_b, {a[6], ua[15], XRP(315), xrp_b.reward, true});
-
5106  ac(13, st, xrp_b, {a[7], ua[16], XRP(316), xrp_b.reward, true});
-
5107  ac(15, st, xrp_b, {a[3], ua[17], XRP(317), xrp_b.reward, true});
-
5108  runSimulation(st, true); // balances verification working now.
-
5109  }
-
5110 
-
5111  void
-
5112  run() override
-
5113  {
-
5114  testXChainSimulation();
-
5115  }
-
5116 };
-
5117 
-
5118 BEAST_DEFINE_TESTSUITE(XChain, app, ripple);
-
5119 BEAST_DEFINE_TESTSUITE(XChainSim, app, ripple);
-
5120 
-
5121 } // namespace ripple::test
+
4926  void
+
4927  testXChainSimulation()
+
4928  {
+
4929  using namespace jtx;
+
4930 
+
4931  testcase("Bridge usage simulation");
+
4932 
+
4933  XEnv mcEnv(*this);
+
4934  XEnv scEnv(*this, true);
+
4935 
+
4936  auto st = std::make_shared<ChainStateTracker>(mcEnv, scEnv);
+
4937 
+
4938  // create 10 accounts + door funded on both chains, and store
+
4939  // in ChainStateTracker the initial amount of these accounts
+
4940  Account doorXRPLocking, doorUSDLocking, doorUSDIssuing;
+
4941 
+
4942  constexpr size_t num_acct = 10;
+
4943  auto a = [&doorXRPLocking, &doorUSDLocking, &doorUSDIssuing]() {
+
4944  using namespace std::literals;
+
4945  std::vector<Account> result;
+
4946  result.reserve(num_acct);
+
4947  for (int i = 0; i < num_acct; ++i)
+
4948  result.emplace_back(
+
4949  "a"s + std::to_string(i),
+
4950  (i % 2) ? KeyType::ed25519 : KeyType::secp256k1);
+
4951  result.emplace_back("doorXRPLocking");
+
4952  doorXRPLocking = result.back();
+
4953  result.emplace_back("doorUSDLocking");
+
4954  doorUSDLocking = result.back();
+
4955  result.emplace_back("doorUSDIssuing");
+
4956  doorUSDIssuing = result.back();
+
4957  return result;
+
4958  }();
+
4959 
+
4960  for (auto& acct : a)
+
4961  {
+
4962  STAmount amt{XRP(100000)};
+
4963 
+
4964  mcEnv.fund(amt, acct);
+
4965  scEnv.fund(amt, acct);
+
4966  }
+
4967  Account USDLocking{"USDLocking"};
+
4968  IOU usdLocking{USDLocking["USD"]};
+
4969  IOU usdIssuing{doorUSDIssuing["USD"]};
+
4970 
+
4971  mcEnv.fund(XRP(100000), USDLocking);
+
4972  mcEnv.close();
+
4973  mcEnv.tx(trust(doorUSDLocking, usdLocking(100000)));
+
4974  mcEnv.close();
+
4975  mcEnv.tx(pay(USDLocking, doorUSDLocking, usdLocking(50000)));
+
4976 
+
4977  for (int i = 0; i < a.size(); ++i)
+
4978  {
+
4979  auto& acct{a[i]};
+
4980  if (i < num_acct)
+
4981  {
+
4982  mcEnv.tx(trust(acct, usdLocking(100000)));
+
4983  scEnv.tx(trust(acct, usdIssuing(100000)));
+
4984  }
+
4985  st->init(acct);
+
4986  }
+
4987  for (auto& s : signers)
+
4988  st->init(s.account);
+
4989 
+
4990  st->b_.init(Account::master);
+
4991 
+
4992  // also create some unfunded accounts
+
4993  constexpr size_t num_ua = 20;
+
4994  auto ua = []() {
+
4995  using namespace std::literals;
+
4996  std::vector<Account> result;
+
4997  result.reserve(num_ua);
+
4998  for (int i = 0; i < num_ua; ++i)
+
4999  result.emplace_back(
+
5000  "ua"s + std::to_string(i),
+
5001  (i % 2) ? KeyType::ed25519 : KeyType::secp256k1);
+
5002  return result;
+
5003  }();
+
5004 
+
5005  // initialize a bridge from a BridgeDef
+
5006  auto initBridge = [&mcEnv, &scEnv, &st](BridgeDef& bd) {
+
5007  bd.initBridge(mcEnv, scEnv);
+
5008  st->a_.spendFee(bd.doorA, 2);
+
5009  st->b_.spendFee(bd.doorB, 2);
+
5010  };
+
5011 
+
5012  // create XRP -> XRP bridge
+
5013  // ------------------------
+
5014  BridgeDef xrp_b{
+
5015  doorXRPLocking,
+
5016  xrpIssue(),
+
5017  Account::master,
+
5018  xrpIssue(),
+
5019  XRP(1),
+
5020  XRP(20),
+
5021  quorum,
+
5022  signers,
+
5023  Json::nullValue};
+
5024 
+
5025  initBridge(xrp_b);
+
5026 
+
5027  // create USD -> USD bridge
+
5028  // ------------------------
+
5029  BridgeDef usd_b{
+
5030  doorUSDLocking,
+
5031  usdLocking,
+
5032  doorUSDIssuing,
+
5033  usdIssuing,
+
5034  XRP(1),
+
5035  XRP(20),
+
5036  quorum,
+
5037  signers,
+
5038  Json::nullValue};
+
5039 
+
5040  initBridge(usd_b);
+
5041 
+
5042  // try a single account create + transfer to validate the simulation
+
5043  // engine. Do the transfer 8 time steps after the account create, to
+
5044  // give time enough for ua[0] to be funded now so it can reserve
+
5045  // the claimID
+
5046  // -----------------------------------------------------------------
+
5047  ac(0, st, xrp_b, {a[0], ua[0], XRP(777), xrp_b.reward, true});
+
5048  xfer(8, st, xrp_b, {a[0], ua[0], a[2], XRP(3), true});
+
5049  runSimulation(st);
+
5050 
+
5051  // try the same thing in the other direction
+
5052  // -----------------------------------------
+
5053  ac(0, st, xrp_b, {a[0], ua[0], XRP(777), xrp_b.reward, false});
+
5054  xfer(8, st, xrp_b, {a[0], ua[0], a[2], XRP(3), false});
+
5055  runSimulation(st);
+
5056 
+
5057  // run multiple XRP transfers
+
5058  // --------------------------
+
5059  xfer(0, st, xrp_b, {a[0], a[0], a[1], XRP(6), true, WithClaim::no});
+
5060  xfer(1, st, xrp_b, {a[0], a[0], a[1], XRP(8), false, WithClaim::no});
+
5061  xfer(1, st, xrp_b, {a[1], a[1], a[1], XRP(1), true});
+
5062  xfer(2, st, xrp_b, {a[0], a[0], a[1], XRP(3), false});
+
5063  xfer(2, st, xrp_b, {a[1], a[1], a[1], XRP(5), false});
+
5064  xfer(2, st, xrp_b, {a[0], a[0], a[1], XRP(7), false, WithClaim::no});
+
5065  xfer(2, st, xrp_b, {a[1], a[1], a[1], XRP(9), true});
+
5066  runSimulation(st);
+
5067 
+
5068  // run one USD transfer
+
5069  // --------------------
+
5070  xfer(0, st, usd_b, {a[0], a[1], a[2], usdLocking(3), true});
+
5071  runSimulation(st);
+
5072 
+
5073  // run multiple USD transfers
+
5074  // --------------------------
+
5075  xfer(0, st, usd_b, {a[0], a[0], a[1], usdLocking(6), true});
+
5076  xfer(1, st, usd_b, {a[0], a[0], a[1], usdIssuing(8), false});
+
5077  xfer(1, st, usd_b, {a[1], a[1], a[1], usdLocking(1), true});
+
5078  xfer(2, st, usd_b, {a[0], a[0], a[1], usdIssuing(3), false});
+
5079  xfer(2, st, usd_b, {a[1], a[1], a[1], usdIssuing(5), false});
+
5080  xfer(2, st, usd_b, {a[0], a[0], a[1], usdIssuing(7), false});
+
5081  xfer(2, st, usd_b, {a[1], a[1], a[1], usdLocking(9), true});
+
5082  runSimulation(st);
+
5083 
+
5084  // run mixed transfers
+
5085  // -------------------
+
5086  xfer(0, st, xrp_b, {a[0], a[0], a[0], XRP(1), true});
+
5087  xfer(0, st, usd_b, {a[1], a[3], a[3], usdIssuing(3), false});
+
5088  xfer(0, st, usd_b, {a[3], a[2], a[1], usdIssuing(5), false});
+
5089 
+
5090  xfer(1, st, xrp_b, {a[0], a[0], a[0], XRP(4), false});
+
5091  xfer(1, st, xrp_b, {a[1], a[1], a[0], XRP(8), true});
+
5092  xfer(1, st, usd_b, {a[4], a[1], a[1], usdLocking(7), true});
+
5093 
+
5094  xfer(3, st, xrp_b, {a[1], a[1], a[0], XRP(7), true});
+
5095  xfer(3, st, xrp_b, {a[0], a[4], a[3], XRP(2), false});
+
5096  xfer(3, st, xrp_b, {a[1], a[1], a[0], XRP(9), true});
+
5097  xfer(3, st, usd_b, {a[3], a[1], a[1], usdIssuing(11), false});
+
5098  runSimulation(st);
+
5099 
+
5100  // run multiple account create to stress attestation batching
+
5101  // ----------------------------------------------------------
+
5102  ac(0, st, xrp_b, {a[0], ua[1], XRP(301), xrp_b.reward, true});
+
5103  ac(0, st, xrp_b, {a[1], ua[2], XRP(302), xrp_b.reward, true});
+
5104  ac(1, st, xrp_b, {a[0], ua[3], XRP(303), xrp_b.reward, true});
+
5105  ac(2, st, xrp_b, {a[1], ua[4], XRP(304), xrp_b.reward, true});
+
5106  ac(3, st, xrp_b, {a[0], ua[5], XRP(305), xrp_b.reward, true});
+
5107  ac(4, st, xrp_b, {a[1], ua[6], XRP(306), xrp_b.reward, true});
+
5108  ac(6, st, xrp_b, {a[0], ua[7], XRP(307), xrp_b.reward, true});
+
5109  ac(7, st, xrp_b, {a[2], ua[8], XRP(308), xrp_b.reward, true});
+
5110  ac(9, st, xrp_b, {a[0], ua[9], XRP(309), xrp_b.reward, true});
+
5111  ac(9, st, xrp_b, {a[0], ua[9], XRP(309), xrp_b.reward, true});
+
5112  ac(10, st, xrp_b, {a[0], ua[10], XRP(310), xrp_b.reward, true});
+
5113  ac(12, st, xrp_b, {a[0], ua[11], XRP(311), xrp_b.reward, true});
+
5114  ac(12, st, xrp_b, {a[3], ua[12], XRP(312), xrp_b.reward, true});
+
5115  ac(12, st, xrp_b, {a[4], ua[13], XRP(313), xrp_b.reward, true});
+
5116  ac(12, st, xrp_b, {a[3], ua[14], XRP(314), xrp_b.reward, true});
+
5117  ac(12, st, xrp_b, {a[6], ua[15], XRP(315), xrp_b.reward, true});
+
5118  ac(13, st, xrp_b, {a[7], ua[16], XRP(316), xrp_b.reward, true});
+
5119  ac(15, st, xrp_b, {a[3], ua[17], XRP(317), xrp_b.reward, true});
+
5120  runSimulation(st, true); // balances verification working now.
+
5121  }
+
5122 
+
5123  void
+
5124  run() override
+
5125  {
+
5126  testXChainSimulation();
+
5127  }
+
5128 };
+
5129 
+
5130 BEAST_DEFINE_TESTSUITE(XChain, app, ripple);
+
5131 BEAST_DEFINE_TESTSUITE(XChainSim, app, ripple);
+
5132 
+
5133 } // namespace ripple::test
-
ripple::test::XChainSim_test::ChainStateTrack::BridgeCounters::signers
std::vector< size_t > signers
Definition: XChain_test.cpp:4444
+
ripple::test::XChainSim_test::ChainStateTrack::BridgeCounters::signers
std::vector< size_t > signers
Definition: XChain_test.cpp:4456
std::apply
T apply(T... args)
ripple::test::SEnv::account
std::shared_ptr< SLE const > account(jtx::Account const &account)
Definition: XChain_test.cpp:147
-
ripple::test::XChainSim_test::Transfer::a2b
bool a2b
Definition: XChain_test.cpp:4236
+
ripple::test::XChainSim_test::Transfer::a2b
bool a2b
Definition: XChain_test.cpp:4248
ripple::test::jtx::XRP
const XRP_t XRP
Converts to XRP Issue or STAmount.
Definition: amount.cpp:105
-
ripple::test::XChainSim_test::ChainStateTrack::tx_fee
STAmount tx_fee
Definition: XChain_test.cpp:4461
+
ripple::test::XChainSim_test::ChainStateTrack::tx_fee
STAmount tx_fee
Definition: XChain_test.cpp:4473
ripple::test::jtx::xchain_commit
Json::Value xchain_commit(Account const &acc, Json::Value const &bridge, std::uint32_t claimID, AnyAmount const &amt, std::optional< Account > const &dst)
Definition: xchain_bridge.cpp:134
ripple::tecXCHAIN_BAD_CLAIM_ID
@ tecXCHAIN_BAD_CLAIM_ID
Definition: TER.h:316
ripple::test::jtx::claim
Json::Value claim(AccountID const &account, uint256 const &channel, std::optional< STAmount > const &balance, std::optional< STAmount > const &amount, std::optional< Slice > const &signature, std::optional< PublicKey > const &pk)
Definition: TestHelpers.cpp:293
-
ripple::test::XChain_test::testXChainCreateBridgeMatrix
void testXChainCreateBridgeMatrix()
Definition: XChain_test.cpp:678
+
ripple::test::XChain_test::testXChainCreateBridgeMatrix
void testXChainCreateBridgeMatrix()
Definition: XChain_test.cpp:690
ripple::test::SEnv::caClaimID
std::shared_ptr< SLE const > caClaimID(Json::Value const &jvb, std::uint64_t seq)
Definition: XChain_test.cpp:190
-
ripple::test::XChainSim_test::ac
void ac(uint64_t time, const std::shared_ptr< ChainStateTracker > &chainstate, BridgeDef const &bridge, AccountCreate ac)
Definition: XChain_test.cpp:4864
+
ripple::test::XChainSim_test::ac
void ac(uint64_t time, const std::shared_ptr< ChainStateTracker > &chainstate, BridgeDef const &bridge, AccountCreate ac)
Definition: XChain_test.cpp:4876
ripple::Issue
A currency issued by an account.
Definition: Issue.h:35
ripple::asfDepositAuth
constexpr std::uint32_t asfDepositAuth
Definition: TxFlags.h:82
-
ripple::test::XChain_test::testXChainBridgeCreateConstraints
void testXChainBridgeCreateConstraints()
Definition: XChain_test.cpp:558
+
ripple::test::XChain_test::testXChainBridgeCreateConstraints
void testXChainBridgeCreateConstraints()
Definition: XChain_test.cpp:559
std::string
STL class.
std::shared_ptr
STL class.
-
ripple::test::XChainSim_test::ChainStateTrack::accounts
std::map< jtx::Account, AccountStateTrack > accounts
Definition: XChain_test.cpp:4458
+
ripple::test::XChainSim_test::ChainStateTrack::accounts
std::map< jtx::Account, AccountStateTrack > accounts
Definition: XChain_test.cpp:4470
-
ripple::test::XChain_test::testXChainCreateAccount
void testXChainCreateAccount()
Definition: XChain_test.cpp:3936
-
ripple::test::XChainSim_test::SmTransfer::attest
bool attest(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4752
-
ripple::test::XChainSim_test::sm_
SmCont sm_
Definition: XChain_test.cpp:4850
+
ripple::test::XChain_test::testXChainCreateAccount
void testXChainCreateAccount()
Definition: XChain_test.cpp:3948
+
ripple::test::XChainSim_test::SmTransfer::attest
bool attest(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4764
+
ripple::test::XChainSim_test::sm_
SmCont sm_
Definition: XChain_test.cpp:4862
std::exception
STL class.
ripple::test::XChain_test::txFee
XRPAmount txFee()
Definition: XChain_test.cpp:399
ripple::tecXCHAIN_CLAIM_NO_QUORUM
@ tecXCHAIN_CLAIM_NO_QUORUM
Definition: TER.h:317
@@ -5161,31 +5173,31 @@ $(function() { -
ripple::test::XChainSim_test::ChainStateTrack::env
ENV & env
Definition: XChain_test.cpp:4457
-
ripple::test::XChainSim_test::SmTransfer::create_claim_id
uint32_t create_claim_id()
Definition: XChain_test.cpp:4701
+
ripple::test::XChainSim_test::ChainStateTrack::env
ENV & env
Definition: XChain_test.cpp:4469
+
ripple::test::XChainSim_test::SmTransfer::create_claim_id
uint32_t create_claim_id()
Definition: XChain_test.cpp:4713
ripple::test::SEnv::claimID
std::uint64_t claimID(Json::Value const &jvb)
Definition: XChain_test.cpp:178
-
ripple::test::XChainSim_test::AccountStateTrack
Definition: XChain_test.cpp:4258
-
ripple::test::XChain_test::testXChainAddAccountCreateNonBatchAttestation
void testXChainAddAccountCreateNonBatchAttestation()
Definition: XChain_test.cpp:2605
+
ripple::test::XChainSim_test::AccountStateTrack
Definition: XChain_test.cpp:4270
+
ripple::test::XChain_test::testXChainAddAccountCreateNonBatchAttestation
void testXChainAddAccountCreateNonBatchAttestation()
Definition: XChain_test.cpp:2617
ripple::STAmount::issue
Issue const & issue() const
Definition: STAmount.h:350
ripple::terNO_LINE
@ terNO_LINE
Definition: TER.h:209
-
ripple::test::XChainSim_test::SmCreateAccount::SmCreateAccount
SmCreateAccount(const std::shared_ptr< ChainStateTracker > &chainstate, const BridgeDef &bridge, AccountCreate create)
Definition: XChain_test.cpp:4552
+
ripple::test::XChainSim_test::SmCreateAccount::SmCreateAccount
SmCreateAccount(const std::shared_ptr< ChainStateTracker > &chainstate, const BridgeDef &bridge, AccountCreate create)
Definition: XChain_test.cpp:4564
ripple::test::jtx::claim_attestations
JValueVec claim_attestations(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, std::vector< jtx::Account > const &rewardAccounts, bool wasLockingChainSend, std::uint64_t claimID, std::optional< jtx::Account > const &dst, std::vector< jtx::signer > const &signers, std::size_t const numAtts, std::size_t const fromIdx)
Definition: xchain_bridge.cpp:306
-
ripple::test::XChain_test::testXChainAddAttestation
void testXChainAddAttestation()
Definition: XChain_test.cpp:1503
-
ripple::test::XChainSim_test::AccountStateTrack::verify
bool verify(ENV &env, jtx::Account const &acct) const
Definition: XChain_test.cpp:4271
+
ripple::test::XChain_test::testXChainAddAttestation
void testXChainAddAttestation()
Definition: XChain_test.cpp:1515
+
ripple::test::XChainSim_test::AccountStateTrack::verify
bool verify(ENV &env, jtx::Account const &acct) const
Definition: XChain_test.cpp:4283
std::vector::reserve
T reserve(T... args)
-
ripple::test::XChainSim_test::AccountCreate::a2b
bool a2b
Definition: XChain_test.cpp:4248
-
ripple::test::XChain_test::testXChainDeleteDoor
void testXChainDeleteDoor()
Definition: XChain_test.cpp:4151
+
ripple::test::XChainSim_test::AccountCreate::a2b
bool a2b
Definition: XChain_test.cpp:4260
+
ripple::test::XChain_test::testXChainDeleteDoor
void testXChainDeleteDoor()
Definition: XChain_test.cpp:4163
ripple::test::BalanceTransfer::BalanceTransfer
BalanceTransfer(T &env, jtx::Account const &from_acct, jtx::Account const &to_acct, jtx::Account const &payor, jtx::Account const *payees, size_t num_payees, bool withClaim)
Definition: XChain_test.cpp:280
-
ripple::test::XChainSim_test::SmCreateAccount::issue_account_create
uint32_t issue_account_create()
Definition: XChain_test.cpp:4569
+
ripple::test::XChainSim_test::SmCreateAccount::issue_account_create
uint32_t issue_account_create()
Definition: XChain_test.cpp:4581
ripple::test::SEnv::fund
SEnv & fund(STAmount const &amount, Arg const &arg, Args const &... args)
Definition: XChain_test.cpp:93
-
ripple::test::XChainSim_test::SmBase::SmBase
SmBase(const std::shared_ptr< ChainStateTracker > &chainstate, const BridgeDef &bridge)
Definition: XChain_test.cpp:4510
+
ripple::test::XChainSim_test::SmBase::SmBase
SmBase(const std::shared_ptr< ChainStateTracker > &chainstate, const BridgeDef &bridge)
Definition: XChain_test.cpp:4522
ripple::test::Balance::Balance
Balance(T &env, jtx::Account const &account)
Definition: XChain_test.cpp:255
-
ripple::test::XChainSim_test::ChainStateTrack::receive
void receive(jtx::Account const &acct, STAmount amt, std::uint64_t divisor=1)
Definition: XChain_test.cpp:4373
+
ripple::test::XChainSim_test::ChainStateTrack::receive
void receive(jtx::Account const &acct, STAmount amt, std::uint64_t divisor=1)
Definition: XChain_test.cpp:4385
ripple::test::jtx::Env::enableFeature
void enableFeature(uint256 const feature)
Definition: Env.cpp:470
std::vector::size
T size(T... args)
@@ -5194,72 +5206,72 @@ $(function() { -
ripple::test::XChainSim_test::SmTransfer
Definition: XChain_test.cpp:4679
+
ripple::test::XChainSim_test::SmTransfer
Definition: XChain_test.cpp:4691
ripple::temXCHAIN_EQUAL_DOOR_ACCOUNTS
@ temXCHAIN_EQUAL_DOOR_ACCOUNTS
Definition: TER.h:129
-
ripple::test::XChainSim_test::ChainStateTracker::b_
ChainStateTrack b_
Definition: XChain_test.cpp:4491
+
ripple::test::XChainSim_test::ChainStateTracker::b_
ChainStateTrack b_
Definition: XChain_test.cpp:4503
ripple::test::jtx::JValueVec
std::vector< Json::Value > JValueVec
Definition: xchain_bridge.h:34
-
ripple::test::XChain_test::testXChainCommit
void testXChainCommit()
Definition: XChain_test.cpp:1367
+
ripple::test::XChain_test::testXChainCommit
void testXChainCommit()
Definition: XChain_test.cpp:1379
ripple::tecDST_TAG_NEEDED
@ tecDST_TAG_NEEDED
Definition: TER.h:287
-
ripple::test::XChainSim_test::SmTransfer::SmTransfer
SmTransfer(const std::shared_ptr< ChainStateTracker > &chainstate, const BridgeDef &bridge, Transfer xfer)
Definition: XChain_test.cpp:4684
+
ripple::test::XChainSim_test::SmTransfer::SmTransfer
SmTransfer(const std::shared_ptr< ChainStateTracker > &chainstate, const BridgeDef &bridge, Transfer xfer)
Definition: XChain_test.cpp:4696
ripple::test::jtx::port_increment
std::unique_ptr< Config > port_increment(std::unique_ptr< Config >, int)
adjust the default configured server ports by a specified value
Definition: envconfig.cpp:128
-
ripple::test::XChainSim_test::ChainStateTrack::counters
std::map< BridgeID, BridgeCounters > counters
Definition: XChain_test.cpp:4460
+
ripple::test::XChainSim_test::ChainStateTrack::counters
std::map< BridgeID, BridgeCounters > counters
Definition: XChain_test.cpp:4472
ripple::tecXCHAIN_NO_CLAIM_ID
@ tecXCHAIN_NO_CLAIM_ID
Definition: TER.h:315
ripple::test::BalanceTransfer::payees_received
bool payees_received(STAmount const &reward) const
Definition: XChain_test.cpp:321
ripple::test::jtx::UT_XCHAIN_DEFAULT_QUORUM
constexpr std::size_t UT_XCHAIN_DEFAULT_QUORUM
Definition: xchain_bridge.h:37
ripple::transToken
std::string transToken(TER code)
Definition: TER.cpp:244
-
ripple::test::XChainSim_test::testXChainSimulation
void testXChainSimulation()
Definition: XChain_test.cpp:4915
+
ripple::test::XChainSim_test::testXChainSimulation
void testXChainSimulation()
Definition: XChain_test.cpp:4927
ripple::test::jtx::claim_attestation
Json::Value claim_attestation(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, jtx::Account const &rewardAccount, bool wasLockingChainSend, std::uint64_t claimID, std::optional< jtx::Account > const &dst, jtx::signer const &signer)
Definition: xchain_bridge.cpp:199
ripple::test::SEnv::multiTx
SEnv & multiTx(jtx::JValueVec &&jvv, FN const &... fN)
Definition: XChain_test.cpp:109
-
ripple::test::XChain_test::testXChainModifyBridge
void testXChainModifyBridge()
Definition: XChain_test.cpp:970
+
ripple::test::XChain_test::testXChainModifyBridge
void testXChainModifyBridge()
Definition: XChain_test.cpp:982
ripple::keylet::xChainClaimID
Keylet xChainClaimID(STXChainBridge const &bridge, std::uint64_t seq)
Definition: Indexes.cpp:413
ripple::test::jtx::Env::balance
PrettyAmount balance(Account const &account) const
Returns the XRP balance on an account.
Definition: Env.cpp:183
ripple::test::jtx::bridge_modify
Json::Value bridge_modify(Account const &acc, Json::Value const &bridge, std::optional< STAmount > const &reward, std::optional< STAmount > const &minAccountCreate)
Definition: xchain_bridge.cpp:92
-
ripple::test::XChainSim_test::SmTransfer::sm_state
SmState sm_state
Definition: XChain_test.cpp:4843
+
ripple::test::XChainSim_test::SmTransfer::sm_state
SmState sm_state
Definition: XChain_test.cpp:4855
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:242
std::vector::back
T back(T... args)
-
ripple::test::XChainSim_test::ChainStateTrack::Claims
Definition: XChain_test.cpp:4448
+
ripple::test::XChainSim_test::ChainStateTrack::Claims
Definition: XChain_test.cpp:4460
ripple::test::SEnv::enableFeature
SEnv & enableFeature(uint256 const feature)
Definition: XChain_test.cpp:78
std::all_of
T all_of(T... args)
-
ripple::test::XChainSim_test::SmBase::destState
ChainStateTrack & destState()
Definition: XChain_test.cpp:4524
+
ripple::test::XChainSim_test::SmBase::destState
ChainStateTrack & destState()
Definition: XChain_test.cpp:4536
-
ripple::test::XChainSim_test::SmBase::srcState
ChainStateTrack & srcState()
Definition: XChain_test.cpp:4518
+
ripple::test::XChainSim_test::SmBase::srcState
ChainStateTrack & srcState()
Definition: XChain_test.cpp:4530
std::tmpnam
T tmpnam(T... args)
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:49
-
ripple::test::XChainSim_test::SmBase::srcDoor
jtx::Account const & srcDoor()
Definition: XChain_test.cpp:4530
+
ripple::test::XChainSim_test::SmBase::srcDoor
jtx::Account const & srcDoor()
Definition: XChain_test.cpp:4542
ripple::SField::getJsonName
Json::StaticString const & getJsonName() const
Definition: SField.h:192
ripple::test::jtx::create_account_attestation
Json::Value create_account_attestation(jtx::Account const &submittingAccount, Json::Value const &jvBridge, jtx::Account const &sendingAccount, jtx::AnyAmount const &sendingAmount, jtx::AnyAmount const &rewardAmount, jtx::Account const &rewardAccount, bool wasLockingChainSend, std::uint64_t createCount, jtx::Account const &dst, jtx::signer const &signer)
Definition: xchain_bridge.cpp:251
-
ripple::test::XChainSim_test::AccountCreate::amt
STAmount amt
Definition: XChain_test.cpp:4246
+
ripple::test::XChainSim_test::AccountCreate::amt
STAmount amt
Definition: XChain_test.cpp:4258
ripple::sfXChainAccountClaimCount
const SF_UINT64 sfXChainAccountClaimCount
-
ripple::test::XChainSim_test::Transfer::finaldest
jtx::Account finaldest
Definition: XChain_test.cpp:4234
+
ripple::test::XChainSim_test::Transfer::finaldest
jtx::Account finaldest
Definition: XChain_test.cpp:4246
ripple::temBAD_ISSUER
@ temBAD_ISSUER
Definition: TER.h:91
-
ripple::test::XChain_test::testXChainClaim
void testXChainClaim()
Definition: XChain_test.cpp:2680
+
ripple::test::XChain_test::testXChainClaim
void testXChainClaim()
Definition: XChain_test.cpp:2692
ripple::test::SEnv::disableFeature
SEnv & disableFeature(uint256 const feature)
Definition: XChain_test.cpp:85
-
ripple::test::XChainSim_test::ChainStateTrack::Claims::xfer_claims
ClaimVec xfer_claims
Definition: XChain_test.cpp:4450
-
ripple::test::XChain_test::testXChainAddClaimNonBatchAttestation
void testXChainAddClaimNonBatchAttestation()
Definition: XChain_test.cpp:2376
+
ripple::test::XChainSim_test::ChainStateTrack::Claims::xfer_claims
ClaimVec xfer_claims
Definition: XChain_test.cpp:4462
+
ripple::test::XChain_test::testXChainAddClaimNonBatchAttestation
void testXChainAddClaimNonBatchAttestation()
Definition: XChain_test.cpp:2388
ripple::SField::jsonName
const Json::StaticString jsonName
Definition: SField.h:141
ripple::test::jtx::Env::ter
TER ter() const
Return the TER for the last JTx.
Definition: Env.h:526
std::vector::front
T front(T... args)
ripple::test::jtx::signer
A signer in a SignerList.
Definition: multisign.h:35
-
ripple::test::XChainSim_test::SmCreateAccount::sm_state
SmState sm_state
Definition: XChain_test.cpp:4674
-
ripple::test::XChainSim_test::SmCreateAccount::attest
void attest(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4586
+
ripple::test::XChainSim_test::SmCreateAccount::sm_state
SmState sm_state
Definition: XChain_test.cpp:4686
+
ripple::test::XChainSim_test::SmCreateAccount::attest
void attest(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4598
ripple::temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT
@ temXCHAIN_BRIDGE_BAD_REWARD_AMOUNT
Definition: TER.h:134
-
ripple::test::XChainSim_test::SmBase
Definition: XChain_test.cpp:4507
+
ripple::test::XChainSim_test::SmBase
Definition: XChain_test.cpp:4519
ripple::test::Balance::diff
STAmount diff() const
Definition: XChain_test.cpp:261
-
ripple::test::XChain_test::run
void run() override
Definition: XChain_test.cpp:4201
+
ripple::test::XChain_test::run
void run() override
Definition: XChain_test.cpp:4213
ripple::sfXChainClaimID
const SF_UINT64 sfXChainClaimID
ripple::temXCHAIN_BRIDGE_BAD_ISSUES
@ temXCHAIN_BRIDGE_BAD_ISSUES
Definition: TER.h:131
ripple::test::SEnv::bridge
std::shared_ptr< SLE const > bridge(Json::Value const &jvb)
Definition: XChain_test.cpp:153
-
ripple::test::XChainSim_test::xfer
void xfer(uint64_t time, const std::shared_ptr< ChainStateTracker > &chainstate, BridgeDef const &bridge, Transfer transfer)
Definition: XChain_test.cpp:4853
+
ripple::test::XChainSim_test::xfer
void xfer(uint64_t time, const std::shared_ptr< ChainStateTracker > &chainstate, BridgeDef const &bridge, Transfer transfer)
Definition: XChain_test.cpp:4865
ripple::test::jtx::xchain_claim
Json::Value xchain_claim(Account const &acc, Json::Value const &bridge, std::uint32_t claimID, AnyAmount const &amt, Account const &dst)
Definition: xchain_bridge.cpp:156
ripple::test::BridgeDef::signers
std::vector< jtx::signer > const & signers
Definition: XChain_test.cpp:365
@@ -5267,25 +5279,25 @@ $(function() {
ripple::test::SEnv::tx
SEnv & tx(JsonValue &&jv, FN const &... fN)
Definition: XChain_test.cpp:101
-
ripple::test::XChainSim_test::st_attesting
@ st_attesting
Definition: XChain_test.cpp:4497
+
ripple::test::XChainSim_test::st_attesting
@ st_attesting
Definition: XChain_test.cpp:4509
ripple::base_uint< 256 >
-
ripple::test::XChainSim_test::AccountCreate
Definition: XChain_test.cpp:4242
+
ripple::test::XChainSim_test::AccountCreate
Definition: XChain_test.cpp:4254
ripple::tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR
@ tecXCHAIN_BAD_PUBLIC_KEY_ACCOUNT_PAIR
Definition: TER.h:329
ripple::temINVALID_FLAG
@ temINVALID_FLAG
Definition: TER.h:109
-
ripple::test::XChainSim_test::Transfer::from
jtx::Account from
Definition: XChain_test.cpp:4232
+
ripple::test::XChainSim_test::Transfer::from
jtx::Account from
Definition: XChain_test.cpp:4244
-
ripple::test::XChainSim_test::AccountCreate::from
jtx::Account from
Definition: XChain_test.cpp:4244
+
ripple::test::XChainSim_test::AccountCreate::from
jtx::Account from
Definition: XChain_test.cpp:4256
-
ripple::test::XChainSim_test::SmTransfer::advance
SmState advance(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4806
+
ripple::test::XChainSim_test::SmTransfer::advance
SmState advance(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4818
ripple::asfDisableMaster
constexpr std::uint32_t asfDisableMaster
Definition: TxFlags.h:77
-
ripple::test::XChainSim_test::AccountCreate::reward
STAmount reward
Definition: XChain_test.cpp:4247
+
ripple::test::XChainSim_test::AccountCreate::reward
STAmount reward
Definition: XChain_test.cpp:4259
ripple::sfSignatureReward
const SF_AMOUNT sfSignatureReward
ripple::test::jtx::signers
Json::Value signers(Account const &account, std::uint32_t quorum, std::vector< signer > const &v)
Definition: multisign.cpp:35
-
ripple::test::XChainSim_test::ChainStateTrack::BridgeCounters::create_callbacks
std::vector< complete_cb > create_callbacks
Definition: XChain_test.cpp:4445
+
ripple::test::XChainSim_test::ChainStateTrack::BridgeCounters::create_callbacks
std::vector< complete_cb > create_callbacks
Definition: XChain_test.cpp:4457
@@ -5293,18 +5305,18 @@ $(function() {
ripple::test::SEnv::claimCount
std::uint64_t claimCount(Json::Value const &jvb)
Definition: XChain_test.cpp:172
ripple::tecDUPLICATE
@ tecDUPLICATE
Definition: TER.h:293
-
ripple::test::XChainSim_test::ChainStateTrack::ChainStateTrack
ChainStateTrack(ENV &env)
Definition: XChain_test.cpp:4286
+
ripple::test::XChainSim_test::ChainStateTrack::ChainStateTrack
ChainStateTrack(ENV &env)
Definition: XChain_test.cpp:4298
ripple::keylet::bridge
Keylet bridge(STXChainBridge const &bridge, STXChainBridge::ChainType chainType)
Definition: Indexes.cpp:400
ripple::Application::config
virtual Config & config()=0
-
ripple::test::XChainSim_test::ChainStateTrack::transfer
void transfer(jtx::Account const &from, jtx::Account const &to, STAmount amt)
Definition: XChain_test.cpp:4411
-
ripple::test::XChainSim_test::run
void run() override
Definition: XChain_test.cpp:5112
+
ripple::test::XChainSim_test::ChainStateTrack::transfer
void transfer(jtx::Account const &from, jtx::Account const &to, STAmount amt)
Definition: XChain_test.cpp:4423
+
ripple::test::XChainSim_test::run
void run() override
Definition: XChain_test.cpp:5124
ripple::test::jtx::XChainBridgeObjects::att_create_acct_vec
JValueVec att_create_acct_vec(std::uint64_t createCount, jtx::AnyAmount const &amt, jtx::Account const &dst, std::size_t const numAtts, std::size_t const fromIdx=0)
Definition: xchain_bridge.h:219
ripple::test::BalanceTransfer::check_most_balances
bool check_most_balances(STAmount const &amt, STAmount const &reward)
Definition: XChain_test.cpp:330
ripple::test::SEnv::balance
STAmount balance(jtx::Account const &account, Issue const &issue) const
Definition: XChain_test.cpp:129
-
ripple::test::XChainSim_test::ChainStateTrack::sendCreateAttestations
uint32_t sendCreateAttestations(size_t signer_idx, BridgeID bridge, CreateClaimVec &claims)
Definition: XChain_test.cpp:4303
+
ripple::test::XChainSim_test::ChainStateTrack::sendCreateAttestations
uint32_t sendCreateAttestations(size_t signer_idx, BridgeID bridge, CreateClaimVec &claims)
Definition: XChain_test.cpp:4315
ripple::test::jtx::fset
Json::Value fset(Account const &account, std::uint32_t on, std::uint32_t off=0)
Add and/or remove flag.
Definition: flags.cpp:28
std::to_string
T to_string(T... args)
ripple::test::BalanceTransfer::reward_accounts
std::vector< balance > reward_accounts
Definition: XChain_test.cpp:277
@@ -5314,16 +5326,16 @@ $(function() {
ripple::test::jtx::txflags
Set the flags on a JTx.
Definition: txflags.h:30
ripple::test::jtx::Env::close
bool close(NetClock::time_point closeTime, std::optional< std::chrono::milliseconds > consensusDelay=std::nullopt)
Close and advance the ledger.
Definition: Env.cpp:121
-
ripple::test::XChainSim_test::SmCreateAccount::advance
SmState advance(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4650
+
ripple::test::XChainSim_test::SmCreateAccount::advance
SmState advance(uint64_t time, uint32_t rnd)
Definition: XChain_test.cpp:4662
ripple::tecUNFUNDED_PAYMENT
@ tecUNFUNDED_PAYMENT
Definition: TER.h:263
-
ripple::test::XChainSim_test::ChainStateTracker::ChainStateTracker
ChainStateTracker(ENV &a_env, ENV &b_env)
Definition: XChain_test.cpp:4466
-
ripple::test::XChainSim_test::WithClaim
WithClaim
Definition: XChain_test.cpp:4229
+
ripple::test::XChainSim_test::ChainStateTracker::ChainStateTracker
ChainStateTracker(ENV &a_env, ENV &b_env)
Definition: XChain_test.cpp:4478
+
ripple::test::XChainSim_test::WithClaim
WithClaim
Definition: XChain_test.cpp:4241
ripple::tecXCHAIN_ACCOUNT_CREATE_PAST
@ tecXCHAIN_ACCOUNT_CREATE_PAST
Definition: TER.h:325
ripple::test::BalanceTransfer::has_happened
bool has_happened(STAmount const &amt, STAmount const &reward, bool check_payer=true)
Definition: XChain_test.cpp:337
std::list::erase
T erase(T... args)
ripple::test::SEnv::claimID
std::shared_ptr< SLE const > claimID(Json::Value const &jvb, std::uint64_t seq)
Definition: XChain_test.cpp:184
-
ripple::test::XChainSim_test::ChainStateTracker::verify
bool verify() const
Definition: XChain_test.cpp:4471
+
ripple::test::XChainSim_test::ChainStateTracker::verify
bool verify() const
Definition: XChain_test.cpp:4483
ripple::ValStatus::current
@ current
This was a new validation and was added.
ripple::temBAD_AMOUNT
@ temBAD_AMOUNT
Definition: TER.h:87
ripple::sfAttestationSignerAccount
const SF_ACCOUNT sfAttestationSignerAccount
@@ -5332,74 +5344,74 @@ $(function() {
ripple::test::BridgeDef::initBridge
void initBridge(ENV &mcEnv, ENV &scEnv)
Definition: XChain_test.cpp:370
-
ripple::test::XChainSim_test::BridgeID
BridgeDef const * BridgeID
Definition: XChain_test.cpp:4254
+
ripple::test::XChainSim_test::BridgeID
BridgeDef const * BridgeID
Definition: XChain_test.cpp:4266
ripple::test::jtx::Account::master
static const Account master
The master account.
Definition: Account.h:47
-
ripple::test::XChainSim_test::ChainStateTrack::init
void init(jtx::Account const &acct)
Definition: XChain_test.cpp:4367
+
ripple::test::XChainSim_test::ChainStateTrack::init
void init(jtx::Account const &acct)
Definition: XChain_test.cpp:4379
ripple::featureXChainBridge
const uint256 featureXChainBridge
-
ripple::test::XChainSim_test::st_attested
@ st_attested
Definition: XChain_test.cpp:4498
-
ripple::test::XChainSim_test::ChainStateTrack::BridgeCounters
Definition: XChain_test.cpp:4432
+
ripple::test::XChainSim_test::st_attested
@ st_attested
Definition: XChain_test.cpp:4510
+
ripple::test::XChainSim_test::ChainStateTrack::BridgeCounters
Definition: XChain_test.cpp:4444
ripple::test::SEnv::reserve
XRPAmount reserve(std::uint32_t count)
Definition: XChain_test.cpp:135
-
ripple::test::XChainSim_test::ChainStateTrack::sendAttestations
void sendAttestations(size_t signer_idx, BridgeID bridge, ClaimVec &claims)
Definition: XChain_test.cpp:4292
+
ripple::test::XChainSim_test::ChainStateTrack::sendAttestations
void sendAttestations(size_t signer_idx, BridgeID bridge, ClaimVec &claims)
Definition: XChain_test.cpp:4304
ripple::test::jtx::UT_XCHAIN_DEFAULT_NUM_SIGNERS
constexpr std::size_t UT_XCHAIN_DEFAULT_NUM_SIGNERS
Definition: xchain_bridge.h:36
-
ripple::test::XChainSim_test::runSimulation
void runSimulation(std::shared_ptr< ChainStateTracker > const &st, bool verify_balances=true)
Definition: XChain_test.cpp:4875
+
ripple::test::XChainSim_test::runSimulation
void runSimulation(std::shared_ptr< ChainStateTracker > const &st, bool verify_balances=true)
Definition: XChain_test.cpp:4887
ripple::tfFillOrKill
constexpr std::uint32_t tfFillOrKill
Definition: TxFlags.h:96
ripple::test::jtx::fee
Set the fee on a JTx.
Definition: fee.h:35
ripple::test::jtx::XChainBridgeObjects::alt_signers
const std::vector< signer > alt_signers
Definition: xchain_bridge.h:189
-
ripple::test::XChainSim_test::SmTransfer::xfer
Transfer xfer
Definition: XChain_test.cpp:4842
+
ripple::test::XChainSim_test::SmTransfer::xfer
Transfer xfer
Definition: XChain_test.cpp:4854
ripple::multiply
STAmount multiply(STAmount const &amount, Rate const &rate)
Definition: Rate2.cpp:47
-
ripple::test::XChainSim_test::ChainStateTrack::spend
void spend(jtx::Account const &acct, STAmount amt, std::uint64_t times=1)
Definition: XChain_test.cpp:4398
-
ripple::test::XChainSim_test::SmTransfer::claim
void claim()
Definition: XChain_test.cpp:4795
-
ripple::test::XChainSim_test::SmBase::dstDoor
jtx::Account const & dstDoor()
Definition: XChain_test.cpp:4536
+
ripple::test::XChainSim_test::ChainStateTrack::spend
void spend(jtx::Account const &acct, STAmount amt, std::uint64_t times=1)
Definition: XChain_test.cpp:4410
+
ripple::test::XChainSim_test::SmTransfer::claim
void claim()
Definition: XChain_test.cpp:4807
+
ripple::test::XChainSim_test::SmBase::dstDoor
jtx::Account const & dstDoor()
Definition: XChain_test.cpp:4548
ripple::test::jtx::seq
Set the sequence number on a JTx.
Definition: seq.h:33
-
ripple::test::XChainSim_test::SmBase::bridge_
const BridgeDef & bridge_
Definition: XChain_test.cpp:4542
+
ripple::test::XChainSim_test::SmBase::bridge_
const BridgeDef & bridge_
Definition: XChain_test.cpp:4554
std::vector::emplace_back
T emplace_back(T... args)
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test::jtx::xchain_create_claim_id
Json::Value xchain_create_claim_id(Account const &acc, Json::Value const &bridge, STAmount const &reward, Account const &otherChainSource)
Definition: xchain_bridge.cpp:115
ripple::Config::features
std::unordered_set< uint256, beast::uhash<> > features
Definition: Config.h:288
-
ripple::test::XChainSim_test::Transfer::amt
STAmount amt
Definition: XChain_test.cpp:4235
+
ripple::test::XChainSim_test::Transfer::amt
STAmount amt
Definition: XChain_test.cpp:4247
ripple::tfClearAccountCreateAmount
constexpr std::uint32_t tfClearAccountCreateAmount
Definition: TxFlags.h:185
ripple::tecXCHAIN_CREATE_ACCOUNT_DISABLED
@ tecXCHAIN_CREATE_ACCOUNT_DISABLED
Definition: TER.h:330
ripple::test::BalanceTransfer::BalanceTransfer
BalanceTransfer(T &env, jtx::Account const &from_acct, jtx::Account const &to_acct, jtx::Account const &payor, std::vector< jtx::Account > const &payees, bool withClaim)
Definition: XChain_test.cpp:302
-
ripple::test::XChainSim_test::st_closed
@ st_closed
Definition: XChain_test.cpp:4500
+
ripple::test::XChainSim_test::st_closed
@ st_closed
Definition: XChain_test.cpp:4512
ripple::test::jtx::sidechain_xchain_account_create
Json::Value sidechain_xchain_account_create(Account const &acc, Json::Value const &bridge, Account const &dst, AnyAmount const &amt, AnyAmount const &reward)
Definition: xchain_bridge.cpp:177
ripple::tecXCHAIN_SELF_COMMIT
@ tecXCHAIN_SELF_COMMIT
Definition: TER.h:328
ripple::test::jtx::IOU
Converts to IOU Issue or STAmount.
Definition: amount.h:291
-
ripple::test::XChainSim_test::ChainStateTrack::Claims::create_claims
CreateClaimMap create_claims
Definition: XChain_test.cpp:4451
-
ripple::test::XChainSim_test::SmCreateAccount
Definition: XChain_test.cpp:4547
-
ripple::test::XChainSim_test::ChainStateTracker
Definition: XChain_test.cpp:4464
+
ripple::test::XChainSim_test::ChainStateTrack::Claims::create_claims
CreateClaimMap create_claims
Definition: XChain_test.cpp:4463
+
ripple::test::XChainSim_test::SmCreateAccount
Definition: XChain_test.cpp:4559
+
ripple::test::XChainSim_test::ChainStateTracker
Definition: XChain_test.cpp:4476
ripple::test::XChain_test::reserve
XRPAmount reserve(std::uint32_t count)
Definition: XChain_test.cpp:393
ripple::temDISABLED
@ temDISABLED
Definition: TER.h:112
-
ripple::test::XChainSim_test::Act_Flags
Act_Flags
Definition: XChain_test.cpp:4503
+
ripple::test::XChainSim_test::Act_Flags
Act_Flags
Definition: XChain_test.cpp:4515
beast::severities::Severity
Severity
Severity level / threshold of a Journal message.
Definition: Journal.h:31
ripple::tecXCHAIN_REWARD_MISMATCH
@ tecXCHAIN_REWARD_MISMATCH
Definition: TER.h:321
std::list::begin
T begin(T... args)
-
ripple::test::XChainSim_test::SmState
SmState
Definition: XChain_test.cpp:4494
+
ripple::test::XChainSim_test::SmState
SmState
Definition: XChain_test.cpp:4506
ripple::test::jtx::regkey
Json::Value regkey(Account const &account, disabled_t)
Disable the regular key.
Definition: regkey.cpp:28
ripple::TERSubset< CanCvtToTER >::fromInt
static constexpr TERSubset fromInt(int from)
Definition: TER.h:395
std
STL namespace.
-
ripple::test::XChainSim_test::ChainStateTrack
Definition: XChain_test.cpp:4280
+
ripple::test::XChainSim_test::ChainStateTrack
Definition: XChain_test.cpp:4292
-
ripple::test::XChainSim_test::ChainStateTracker::sendAttestations
void sendAttestations()
Definition: XChain_test.cpp:4477
+
ripple::test::XChainSim_test::ChainStateTracker::sendAttestations
void sendAttestations()
Definition: XChain_test.cpp:4489
ripple::test::jtx::Env::fund
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition: Env.cpp:228
ripple::test::jtx::Env::le
std::shared_ptr< SLE const > le(Account const &account) const
Return an account root.
Definition: Env.cpp:216
ripple::tecNO_ISSUER
@ tecNO_ISSUER
Definition: TER.h:277
Json::nullValue
@ nullValue
'null' value
Definition: json_value.h:36
-
ripple::test::XChainSim_test::Transfer
Definition: XChain_test.cpp:4230
+
ripple::test::XChainSim_test::Transfer
Definition: XChain_test.cpp:4242
ripple::asfRequireDest
constexpr std::uint32_t asfRequireDest
Definition: TxFlags.h:74
-
ripple::test::XChainSim_test::ChainStateTracker::init
void init(jtx::Account const &acct)
Definition: XChain_test.cpp:4484
+
ripple::test::XChainSim_test::ChainStateTracker::init
void init(jtx::Account const &acct)
Definition: XChain_test.cpp:4496
ripple::tecHAS_OBLIGATIONS
@ tecHAS_OBLIGATIONS
Definition: TER.h:295
ripple::tecNO_PERMISSION
@ tecNO_PERMISSION
Definition: TER.h:283
@@ -5407,7 +5419,7 @@ $(function() {
ripple::test::jtx::XChainBridgeObjects::payees
const std::vector< Account > payees
Definition: xchain_bridge.h:191
-
ripple::test::XChainSim_test::ChainStateTrack::sendAttestations
void sendAttestations()
Definition: XChain_test.cpp:4324
+
ripple::test::XChainSim_test::ChainStateTrack::sendAttestations
void sendAttestations()
Definition: XChain_test.cpp:4336
ripple::test::jtx::acctdelete
Json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
Definition: acctdelete.cpp:29
std::count
T count(T... args)
ripple::keylet::xChainCreateAccountClaimID
Keylet xChainCreateAccountClaimID(STXChainBridge const &bridge, std::uint64_t seq)
Definition: Indexes.cpp:427
@@ -5415,64 +5427,64 @@ $(function() {
ripple::tecINSUFFICIENT_RESERVE
@ tecINSUFFICIENT_RESERVE
Definition: TER.h:285
std::list::empty
T empty(T... args)
ripple::xrpIssue
Issue const & xrpIssue()
Returns an asset specifier that represents XRP.
Definition: Issue.h:105
-
ripple::test::XChainSim_test::ChainStateTrack::verify
bool verify() const
Definition: XChain_test.cpp:4424
+
ripple::test::XChainSim_test::ChainStateTrack::verify
bool verify() const
Definition: XChain_test.cpp:4436
-
ripple::test::XChainSim_test::SmCreateAccount::a2b
bool a2b() const
Definition: XChain_test.cpp:4563
+
ripple::test::XChainSim_test::SmCreateAccount::a2b
bool a2b() const
Definition: XChain_test.cpp:4575
ripple::temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT
@ temXCHAIN_BRIDGE_BAD_MIN_ACCOUNT_CREATE_AMOUNT
Definition: TER.h:133
-
ripple::test::XChainSim_test::st_claimid_created
@ st_claimid_created
Definition: XChain_test.cpp:4496
+
ripple::test::XChainSim_test::st_claimid_created
@ st_claimid_created
Definition: XChain_test.cpp:4508
ripple::test::jtx::PrettyAmount::value
STAmount const & value() const
Definition: amount.h:124
-
ripple::test::XChainSim_test::AccountCreate::to
jtx::Account to
Definition: XChain_test.cpp:4245
+
ripple::test::XChainSim_test::AccountCreate::to
jtx::Account to
Definition: XChain_test.cpp:4257
ripple::test::jtx::Account
Immutable cryptographic account descriptor.
Definition: Account.h:37
std::make_pair
T make_pair(T... args)
-
ripple::test::XChainSim_test::AccountStateTrack::init
void init(ENV &env, jtx::Account const &acct)
Definition: XChain_test.cpp:4264
+
ripple::test::XChainSim_test::AccountStateTrack::init
void init(ENV &env, jtx::Account const &acct)
Definition: XChain_test.cpp:4276
-
ripple::test::XChain_test::testXChainCreateClaimID
void testXChainCreateClaimID()
Definition: XChain_test.cpp:1277
+
ripple::test::XChain_test::testXChainCreateClaimID
void testXChainCreateClaimID()
Definition: XChain_test.cpp:1289
ripple::test::XChain_test
Definition: XChain_test.cpp:389
ripple::tecNO_ENTRY
@ tecNO_ENTRY
Definition: TER.h:284
std::list::end
T end(T... args)
ripple::temMALFORMED
@ temMALFORMED
Definition: TER.h:85
-
ripple::test::XChainSim_test::st_initial
@ st_initial
Definition: XChain_test.cpp:4495
-
ripple::test::XChainSim_test::ChainStateTrack::spendFee
void spendFee(jtx::Account const &acct, size_t times=1)
Definition: XChain_test.cpp:4418
+
ripple::test::XChainSim_test::st_initial
@ st_initial
Definition: XChain_test.cpp:4507
+
ripple::test::XChainSim_test::ChainStateTrack::spendFee
void spendFee(jtx::Account const &acct, size_t times=1)
Definition: XChain_test.cpp:4430
-
ripple::test::XChainSim_test::SmTransfer::distribute_reward
void distribute_reward(ChainStateTrack &st)
Definition: XChain_test.cpp:4738
+
ripple::test::XChainSim_test::SmTransfer::distribute_reward
void distribute_reward(ChainStateTrack &st)
Definition: XChain_test.cpp:4750
ripple::test::jtx::XChainBridgeObjects::create_bridge
Json::Value create_bridge(Account const &acc, Json::Value const &bridge=Json::nullValue, STAmount const &_reward=XRP(1), std::optional< STAmount > const &minAccountCreate=std::nullopt)
Definition: xchain_bridge.h:242
-
ripple::test::XChainSim_test::ChainStateTracker::a_
ChainStateTrack a_
Definition: XChain_test.cpp:4490
+
ripple::test::XChainSim_test::ChainStateTracker::a_
ChainStateTrack a_
Definition: XChain_test.cpp:4502
ripple::test::jtx::Env::memoize
void memoize(Account const &account)
Associate AccountID with account.
Definition: Env.cpp:156
ripple::test::jtx::bridge_create
Json::Value bridge_create(Account const &acc, Json::Value const &bridge, STAmount const &reward, std::optional< STAmount > const &minAccountCreate)
Definition: xchain_bridge.cpp:71
std::unique_ptr
STL class.
-
ripple::test::XChainSim_test::SmCreateAccount::cr
AccountCreate cr
Definition: XChain_test.cpp:4675
+
ripple::test::XChainSim_test::SmCreateAccount::cr
AccountCreate cr
Definition: XChain_test.cpp:4687
ripple::test::XEnv::XEnv
XEnv(T &s, bool side=false)
Definition: XChain_test.cpp:204
ripple::test::SEnv::balance
STAmount balance(jtx::Account const &account) const
Definition: XChain_test.cpp:123
-
ripple::test::XChainSim_test::Transfer::to
jtx::Account to
Definition: XChain_test.cpp:4233
+
ripple::test::XChainSim_test::Transfer::to
jtx::Account to
Definition: XChain_test.cpp:4245
ripple::sfXChainBridge
const SF_XCHAIN_BRIDGE sfXChainBridge
ripple::temXCHAIN_BRIDGE_NONDOOR_OWNER
@ temXCHAIN_BRIDGE_NONDOOR_OWNER
Definition: TER.h:132
ripple::tesSUCCESS
@ tesSUCCESS
Definition: TER.h:233
ripple::tecXCHAIN_NO_SIGNERS_LIST
@ tecXCHAIN_NO_SIGNERS_LIST
Definition: TER.h:322
-
ripple::test::XChain_test::testFeeDipsIntoReserve
void testFeeDipsIntoReserve()
Definition: XChain_test.cpp:4101
+
ripple::test::XChain_test::testFeeDipsIntoReserve
void testFeeDipsIntoReserve()
Definition: XChain_test.cpp:4113
ripple::test::jtx::Env::current
std::shared_ptr< OpenView const > current() const
Returns the current ledger.
Definition: Env.h:301
-
ripple::test::XChainSim_test::SmTransfer::a2b
bool a2b() const
Definition: XChain_test.cpp:4695
-
ripple::test::XChainSim_test::SmTransfer::commit
void commit()
Definition: XChain_test.cpp:4715
+
ripple::test::XChainSim_test::SmTransfer::a2b
bool a2b() const
Definition: XChain_test.cpp:4707
+
ripple::test::XChainSim_test::SmTransfer::commit
void commit()
Definition: XChain_test.cpp:4727
ripple::test::jtx::create
Json::Value create(AccountID const &account, AccountID const &to, STAmount const &amount, NetClock::duration const &settleDelay, PublicKey const &pk, std::optional< NetClock::time_point > const &cancelAfter, std::optional< std::uint32_t > const &dstTag)
Definition: TestHelpers.cpp:250
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:117
ripple::tecNO_DST
@ tecNO_DST
Definition: TER.h:268
ripple::test::SEnv::SEnv
SEnv(T &s, std::unique_ptr< Config > config, FeatureBitset features, std::unique_ptr< Logs > logs=nullptr, beast::severities::Severity thresh=beast::severities::kError)
Definition: XChain_test.cpp:60
ripple::test::jtx::XChainBridgeObjects::signers
const std::vector< signer > signers
Definition: xchain_bridge.h:188
-
ripple::test::XChainSim_test::st_completed
@ st_completed
Definition: XChain_test.cpp:4499
+
ripple::test::XChainSim_test::st_completed
@ st_completed
Definition: XChain_test.cpp:4511
Json::Value
Represents a JSON value.
Definition: json_value.h:145
-
ripple::test::XChainSim_test::ChainStateTrack::signers_attns
SignersAttns signers_attns
Definition: XChain_test.cpp:4459
+
ripple::test::XChainSim_test::ChainStateTrack::signers_attns
SignersAttns signers_attns
Definition: XChain_test.cpp:4471
-
ripple::test::XChainSim_test::SmBase::st_
std::shared_ptr< ChainStateTracker > st_
Definition: XChain_test.cpp:4543
+
ripple::test::XChainSim_test::SmBase::st_
std::shared_ptr< ChainStateTracker > st_
Definition: XChain_test.cpp:4555
-
ripple::test::XChainSim_test
Definition: XChain_test.cpp:4222
+
ripple::test::XChainSim_test
Definition: XChain_test.cpp:4234
ripple::tecXCHAIN_INSUFF_CREATE_AMOUNT
@ tecXCHAIN_INSUFF_CREATE_AMOUNT
Definition: TER.h:324
ripple::test::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(DeliverMin, app, ripple)
diff --git a/classripple_1_1BridgeModify.html b/classripple_1_1BridgeModify.html index 767fd06a3b..5c6675dd2b 100644 --- a/classripple_1_1BridgeModify.html +++ b/classripple_1_1BridgeModify.html @@ -323,7 +323,7 @@ Static Private Member Functions
-

Definition at line 1542 of file XChainBridge.cpp.

+

Definition at line 1548 of file XChainBridge.cpp.

@@ -351,7 +351,7 @@ Static Private Member Functions
-

Definition at line 1595 of file XChainBridge.cpp.

+

Definition at line 1601 of file XChainBridge.cpp.

@@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 1612 of file XChainBridge.cpp.

+

Definition at line 1618 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainAddAccountCreateAttestation.html b/classripple_1_1XChainAddAccountCreateAttestation.html index c8ae393706..a4627f40c2 100644 --- a/classripple_1_1XChainAddAccountCreateAttestation.html +++ b/classripple_1_1XChainAddAccountCreateAttestation.html @@ -323,7 +323,7 @@ Static Private Member Functions
-

Definition at line 2139 of file XChainBridge.cpp.

+

Definition at line 2145 of file XChainBridge.cpp.

@@ -351,7 +351,7 @@ Static Private Member Functions
-

Definition at line 2145 of file XChainBridge.cpp.

+

Definition at line 2151 of file XChainBridge.cpp.

@@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 2151 of file XChainBridge.cpp.

+

Definition at line 2157 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainAddClaimAttestation.html b/classripple_1_1XChainAddClaimAttestation.html index 1227a5e7c3..4be3fc3ace 100644 --- a/classripple_1_1XChainAddClaimAttestation.html +++ b/classripple_1_1XChainAddClaimAttestation.html @@ -323,7 +323,7 @@ Static Private Member Functions
-

Definition at line 2119 of file XChainBridge.cpp.

+

Definition at line 2125 of file XChainBridge.cpp.

@@ -351,7 +351,7 @@ Static Private Member Functions
-

Definition at line 2125 of file XChainBridge.cpp.

+

Definition at line 2131 of file XChainBridge.cpp.

@@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 2131 of file XChainBridge.cpp.

+

Definition at line 2137 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainClaim.html b/classripple_1_1XChainClaim.html index ec50116ecd..7b5c3bdbfd 100644 --- a/classripple_1_1XChainClaim.html +++ b/classripple_1_1XChainClaim.html @@ -323,7 +323,7 @@ Static Private Member Functions
-

Definition at line 1652 of file XChainBridge.cpp.

+

Definition at line 1658 of file XChainBridge.cpp.

@@ -351,7 +351,7 @@ Static Private Member Functions
-

Definition at line 1677 of file XChainBridge.cpp.

+

Definition at line 1683 of file XChainBridge.cpp.

@@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 1761 of file XChainBridge.cpp.

+

Definition at line 1767 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainCommit.html b/classripple_1_1XChainCommit.html index 1632d5c66f..e14dfe9019 100644 --- a/classripple_1_1XChainCommit.html +++ b/classripple_1_1XChainCommit.html @@ -325,7 +325,7 @@ Static Private Member Functions
-

Definition at line 1877 of file XChainBridge.cpp.

+

Definition at line 1883 of file XChainBridge.cpp.

@@ -353,7 +353,7 @@ Static Private Member Functions
-

Definition at line 1890 of file XChainBridge.cpp.

+

Definition at line 1896 of file XChainBridge.cpp.

@@ -381,7 +381,7 @@ Static Private Member Functions
-

Definition at line 1915 of file XChainBridge.cpp.

+

Definition at line 1921 of file XChainBridge.cpp.

@@ -410,7 +410,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 1960 of file XChainBridge.cpp.

+

Definition at line 1966 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainCreateAccountCommit.html b/classripple_1_1XChainCreateAccountCommit.html index f34d448a7a..9dd614ec5f 100644 --- a/classripple_1_1XChainCreateAccountCommit.html +++ b/classripple_1_1XChainCreateAccountCommit.html @@ -323,7 +323,7 @@ Static Private Member Functions
-

Definition at line 2159 of file XChainBridge.cpp.

+

Definition at line 2165 of file XChainBridge.cpp.

@@ -351,7 +351,7 @@ Static Private Member Functions
-

Definition at line 2186 of file XChainBridge.cpp.

+

Definition at line 2192 of file XChainBridge.cpp.

@@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 2245 of file XChainBridge.cpp.

+

Definition at line 2251 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainCreateBridge.html b/classripple_1_1XChainCreateBridge.html index cc1d1e1f7a..e5f38472f4 100644 --- a/classripple_1_1XChainCreateBridge.html +++ b/classripple_1_1XChainCreateBridge.html @@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 1496 of file XChainBridge.cpp.

+

Definition at line 1502 of file XChainBridge.cpp.

diff --git a/classripple_1_1XChainCreateClaimID.html b/classripple_1_1XChainCreateClaimID.html index d53eb6ae57..d9a146b855 100644 --- a/classripple_1_1XChainCreateClaimID.html +++ b/classripple_1_1XChainCreateClaimID.html @@ -323,7 +323,7 @@ Static Private Member Functions
-

Definition at line 2004 of file XChainBridge.cpp.

+

Definition at line 2010 of file XChainBridge.cpp.

@@ -351,7 +351,7 @@ Static Private Member Functions
-

Definition at line 2024 of file XChainBridge.cpp.

+

Definition at line 2030 of file XChainBridge.cpp.

@@ -380,7 +380,7 @@ Static Private Member Functions

Implements ripple::Transactor.

-

Definition at line 2061 of file XChainBridge.cpp.

+

Definition at line 2067 of file XChainBridge.cpp.

diff --git a/classripple_1_1test_1_1XChainSim__test_1_1SmBase.html b/classripple_1_1test_1_1XChainSim__test_1_1SmBase.html index 85f1252a17..3bc9ae9386 100644 --- a/classripple_1_1test_1_1XChainSim__test_1_1SmBase.html +++ b/classripple_1_1test_1_1XChainSim__test_1_1SmBase.html @@ -156,7 +156,7 @@ Protected Attributes class ripple::test::XChainSim_test::SmBase< T > -

Definition at line 4507 of file XChain_test.cpp.

+

Definition at line 4519 of file XChain_test.cpp.

Constructor & Destructor Documentation

◆ SmBase()

@@ -186,7 +186,7 @@ template<class T >
-

Definition at line 4510 of file XChain_test.cpp.

+

Definition at line 4522 of file XChain_test.cpp.

@@ -208,7 +208,7 @@ template<class T >
-

Definition at line 4518 of file XChain_test.cpp.

+

Definition at line 4530 of file XChain_test.cpp.

@@ -229,7 +229,7 @@ template<class T >
-

Definition at line 4524 of file XChain_test.cpp.

+

Definition at line 4536 of file XChain_test.cpp.

@@ -250,7 +250,7 @@ template<class T >
-

Definition at line 4530 of file XChain_test.cpp.

+

Definition at line 4542 of file XChain_test.cpp.

@@ -271,7 +271,7 @@ template<class T >
-

Definition at line 4536 of file XChain_test.cpp.

+

Definition at line 4548 of file XChain_test.cpp.

@@ -298,7 +298,7 @@ template<class T >
-

Definition at line 4542 of file XChain_test.cpp.

+

Definition at line 4554 of file XChain_test.cpp.

@@ -324,7 +324,7 @@ template<class T >
-

Definition at line 4543 of file XChain_test.cpp.

+

Definition at line 4555 of file XChain_test.cpp.

diff --git a/classripple_1_1test_1_1XChainSim__test_1_1SmCreateAccount.html b/classripple_1_1test_1_1XChainSim__test_1_1SmCreateAccount.html index 709bf0d7b2..b9928a572f 100644 --- a/classripple_1_1test_1_1XChainSim__test_1_1SmCreateAccount.html +++ b/classripple_1_1test_1_1XChainSim__test_1_1SmCreateAccount.html @@ -184,7 +184,7 @@ Private Attributes

Detailed Description

-

Definition at line 4547 of file XChain_test.cpp.

+

Definition at line 4559 of file XChain_test.cpp.

Member Typedef Documentation

◆ Base

@@ -198,7 +198,7 @@ Private Attributes
-

Definition at line 4550 of file XChain_test.cpp.

+

Definition at line 4562 of file XChain_test.cpp.

@@ -235,7 +235,7 @@ Private Attributes
-

Definition at line 4552 of file XChain_test.cpp.

+

Definition at line 4564 of file XChain_test.cpp.

@@ -255,7 +255,7 @@ Private Attributes
-

Definition at line 4563 of file XChain_test.cpp.

+

Definition at line 4575 of file XChain_test.cpp.

@@ -274,7 +274,7 @@ Private Attributes
-

Definition at line 4569 of file XChain_test.cpp.

+

Definition at line 4581 of file XChain_test.cpp.

@@ -304,7 +304,7 @@ Private Attributes
-

Definition at line 4586 of file XChain_test.cpp.

+

Definition at line 4598 of file XChain_test.cpp.

@@ -334,7 +334,7 @@ Private Attributes
-

Definition at line 4650 of file XChain_test.cpp.

+

Definition at line 4662 of file XChain_test.cpp.

@@ -358,7 +358,7 @@ Private Attributes
-

Definition at line 4518 of file XChain_test.cpp.

+

Definition at line 4530 of file XChain_test.cpp.

@@ -382,7 +382,7 @@ Private Attributes
-

Definition at line 4524 of file XChain_test.cpp.

+

Definition at line 4536 of file XChain_test.cpp.

@@ -406,7 +406,7 @@ Private Attributes
-

Definition at line 4530 of file XChain_test.cpp.

+

Definition at line 4542 of file XChain_test.cpp.

@@ -430,7 +430,7 @@ Private Attributes
-

Definition at line 4536 of file XChain_test.cpp.

+

Definition at line 4548 of file XChain_test.cpp.

@@ -455,7 +455,7 @@ Private Attributes
-

Definition at line 4674 of file XChain_test.cpp.

+

Definition at line 4686 of file XChain_test.cpp.

@@ -479,7 +479,7 @@ Private Attributes
-

Definition at line 4675 of file XChain_test.cpp.

+

Definition at line 4687 of file XChain_test.cpp.

@@ -503,7 +503,7 @@ Private Attributes
-

Definition at line 4542 of file XChain_test.cpp.

+

Definition at line 4554 of file XChain_test.cpp.

@@ -527,7 +527,7 @@ Private Attributes
-

Definition at line 4543 of file XChain_test.cpp.

+

Definition at line 4555 of file XChain_test.cpp.

diff --git a/classripple_1_1test_1_1XChainSim__test_1_1SmTransfer.html b/classripple_1_1test_1_1XChainSim__test_1_1SmTransfer.html index 9866991d0b..7359420443 100644 --- a/classripple_1_1test_1_1XChainSim__test_1_1SmTransfer.html +++ b/classripple_1_1test_1_1XChainSim__test_1_1SmTransfer.html @@ -190,7 +190,7 @@ Private Attributes

Detailed Description

-

Definition at line 4679 of file XChain_test.cpp.

+

Definition at line 4691 of file XChain_test.cpp.

Member Typedef Documentation

◆ Base

@@ -204,7 +204,7 @@ Private Attributes
-

Definition at line 4682 of file XChain_test.cpp.

+

Definition at line 4694 of file XChain_test.cpp.

@@ -241,7 +241,7 @@ Private Attributes
-

Definition at line 4684 of file XChain_test.cpp.

+

Definition at line 4696 of file XChain_test.cpp.

@@ -261,7 +261,7 @@ Private Attributes
-

Definition at line 4695 of file XChain_test.cpp.

+

Definition at line 4707 of file XChain_test.cpp.

@@ -280,7 +280,7 @@ Private Attributes
-

Definition at line 4701 of file XChain_test.cpp.

+

Definition at line 4713 of file XChain_test.cpp.

@@ -299,7 +299,7 @@ Private Attributes
-

Definition at line 4715 of file XChain_test.cpp.

+

Definition at line 4727 of file XChain_test.cpp.

@@ -319,7 +319,7 @@ Private Attributes
-

Definition at line 4738 of file XChain_test.cpp.

+

Definition at line 4750 of file XChain_test.cpp.

@@ -349,7 +349,7 @@ Private Attributes
-

Definition at line 4752 of file XChain_test.cpp.

+

Definition at line 4764 of file XChain_test.cpp.

@@ -368,7 +368,7 @@ Private Attributes
-

Definition at line 4795 of file XChain_test.cpp.

+

Definition at line 4807 of file XChain_test.cpp.

@@ -398,7 +398,7 @@ Private Attributes
-

Definition at line 4806 of file XChain_test.cpp.

+

Definition at line 4818 of file XChain_test.cpp.

@@ -422,7 +422,7 @@ Private Attributes
-

Definition at line 4518 of file XChain_test.cpp.

+

Definition at line 4530 of file XChain_test.cpp.

@@ -446,7 +446,7 @@ Private Attributes
-

Definition at line 4524 of file XChain_test.cpp.

+

Definition at line 4536 of file XChain_test.cpp.

@@ -470,7 +470,7 @@ Private Attributes
-

Definition at line 4530 of file XChain_test.cpp.

+

Definition at line 4542 of file XChain_test.cpp.

@@ -494,7 +494,7 @@ Private Attributes
-

Definition at line 4536 of file XChain_test.cpp.

+

Definition at line 4548 of file XChain_test.cpp.

@@ -519,7 +519,7 @@ Private Attributes
-

Definition at line 4842 of file XChain_test.cpp.

+

Definition at line 4854 of file XChain_test.cpp.

@@ -543,7 +543,7 @@ Private Attributes
-

Definition at line 4843 of file XChain_test.cpp.

+

Definition at line 4855 of file XChain_test.cpp.

@@ -567,7 +567,7 @@ Private Attributes
-

Definition at line 4542 of file XChain_test.cpp.

+

Definition at line 4554 of file XChain_test.cpp.

@@ -591,7 +591,7 @@ Private Attributes
-

Definition at line 4543 of file XChain_test.cpp.

+

Definition at line 4555 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test.html b/structripple_1_1test_1_1XChainSim__test.html index f4efb37093..5d0c243a0f 100644 --- a/structripple_1_1test_1_1XChainSim__test.html +++ b/structripple_1_1test_1_1XChainSim__test.html @@ -310,7 +310,7 @@ Static Private Attributes

Detailed Description

-

Definition at line 4222 of file XChain_test.cpp.

+

Definition at line 4234 of file XChain_test.cpp.

Member Typedef Documentation

◆ ENV

@@ -332,7 +332,7 @@ Static Private Attributes
-

Definition at line 4253 of file XChain_test.cpp.

+

Definition at line 4265 of file XChain_test.cpp.

@@ -356,7 +356,7 @@ Static Private Attributes
-

Definition at line 4254 of file XChain_test.cpp.

+

Definition at line 4266 of file XChain_test.cpp.

@@ -380,7 +380,7 @@ Static Private Attributes
-

Definition at line 4847 of file XChain_test.cpp.

+

Definition at line 4859 of file XChain_test.cpp.

@@ -404,7 +404,7 @@ Static Private Attributes
-

Definition at line 4848 of file XChain_test.cpp.

+

Definition at line 4860 of file XChain_test.cpp.

@@ -433,7 +433,7 @@ Static Private Attributes yes  -

Definition at line 4229 of file XChain_test.cpp.

+

Definition at line 4241 of file XChain_test.cpp.

@@ -465,7 +465,7 @@ Static Private Attributes st_closed  -

Definition at line 4494 of file XChain_test.cpp.

+

Definition at line 4506 of file XChain_test.cpp.

@@ -492,7 +492,7 @@ Static Private Attributes Enumeratoraf_a2b  -

Definition at line 4503 of file XChain_test.cpp.

+

Definition at line 4515 of file XChain_test.cpp.

@@ -543,7 +543,7 @@ Static Private Attributes
-

Definition at line 4853 of file XChain_test.cpp.

+

Definition at line 4865 of file XChain_test.cpp.

@@ -593,7 +593,7 @@ Static Private Attributes
-

Definition at line 4864 of file XChain_test.cpp.

+

Definition at line 4876 of file XChain_test.cpp.

@@ -623,7 +623,7 @@ Static Private Attributes
-

Definition at line 4875 of file XChain_test.cpp.

+

Definition at line 4887 of file XChain_test.cpp.

@@ -642,7 +642,7 @@ Static Private Attributes
-

Definition at line 4915 of file XChain_test.cpp.

+

Definition at line 4927 of file XChain_test.cpp.

@@ -669,7 +669,7 @@ Static Private Attributes
-

Definition at line 5112 of file XChain_test.cpp.

+

Definition at line 5124 of file XChain_test.cpp.

@@ -894,7 +894,7 @@ Static Private Attributes
-

Definition at line 4226 of file XChain_test.cpp.

+

Definition at line 4238 of file XChain_test.cpp.

@@ -918,7 +918,7 @@ Static Private Attributes
-

Definition at line 4850 of file XChain_test.cpp.

+

Definition at line 4862 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1AccountCreate.html b/structripple_1_1test_1_1XChainSim__test_1_1AccountCreate.html index 7fa0804d37..35cedc6160 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1AccountCreate.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1AccountCreate.html @@ -121,7 +121,7 @@ Public Attributes

Detailed Description

-

Definition at line 4242 of file XChain_test.cpp.

+

Definition at line 4254 of file XChain_test.cpp.

Member Data Documentation

◆ from

@@ -135,7 +135,7 @@ Public Attributes
-

Definition at line 4244 of file XChain_test.cpp.

+

Definition at line 4256 of file XChain_test.cpp.

@@ -151,7 +151,7 @@ Public Attributes
-

Definition at line 4245 of file XChain_test.cpp.

+

Definition at line 4257 of file XChain_test.cpp.

@@ -167,7 +167,7 @@ Public Attributes
-

Definition at line 4246 of file XChain_test.cpp.

+

Definition at line 4258 of file XChain_test.cpp.

@@ -183,7 +183,7 @@ Public Attributes
-

Definition at line 4247 of file XChain_test.cpp.

+

Definition at line 4259 of file XChain_test.cpp.

@@ -199,7 +199,7 @@ Public Attributes
-

Definition at line 4248 of file XChain_test.cpp.

+

Definition at line 4260 of file XChain_test.cpp.

@@ -215,7 +215,7 @@ Public Attributes
-

Definition at line 4249 of file XChain_test.cpp.

+

Definition at line 4261 of file XChain_test.cpp.

@@ -231,7 +231,7 @@ Public Attributes
-

Definition at line 4250 of file XChain_test.cpp.

+

Definition at line 4262 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1AccountStateTrack.html b/structripple_1_1test_1_1XChainSim__test_1_1AccountStateTrack.html index 63f8713b4e..2648b4d5a8 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1AccountStateTrack.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1AccountStateTrack.html @@ -112,7 +112,7 @@ Public Attributes

Detailed Description

-

Definition at line 4258 of file XChain_test.cpp.

+

Definition at line 4270 of file XChain_test.cpp.

Member Function Documentation

◆ init()

@@ -140,7 +140,7 @@ Public Attributes
-

Definition at line 4264 of file XChain_test.cpp.

+

Definition at line 4276 of file XChain_test.cpp.

@@ -170,7 +170,7 @@ Public Attributes
-

Definition at line 4271 of file XChain_test.cpp.

+

Definition at line 4283 of file XChain_test.cpp.

@@ -187,7 +187,7 @@ Public Attributes
-

Definition at line 4260 of file XChain_test.cpp.

+

Definition at line 4272 of file XChain_test.cpp.

@@ -203,7 +203,7 @@ Public Attributes
-

Definition at line 4261 of file XChain_test.cpp.

+

Definition at line 4273 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack.html b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack.html index 1e8ef6e0ca..57efa5f9dd 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack.html @@ -191,7 +191,7 @@ Public Attributes

Detailed Description

-

Definition at line 4280 of file XChain_test.cpp.

+

Definition at line 4292 of file XChain_test.cpp.

Member Typedef Documentation

◆ ClaimVec

@@ -205,7 +205,7 @@ Public Attributes
-

Definition at line 4282 of file XChain_test.cpp.

+

Definition at line 4294 of file XChain_test.cpp.

@@ -221,7 +221,7 @@ Public Attributes
-

Definition at line 4283 of file XChain_test.cpp.

+

Definition at line 4295 of file XChain_test.cpp.

@@ -237,7 +237,7 @@ Public Attributes
-

Definition at line 4284 of file XChain_test.cpp.

+

Definition at line 4296 of file XChain_test.cpp.

@@ -253,7 +253,7 @@ Public Attributes
-

Definition at line 4454 of file XChain_test.cpp.

+

Definition at line 4466 of file XChain_test.cpp.

@@ -269,7 +269,7 @@ Public Attributes
-

Definition at line 4455 of file XChain_test.cpp.

+

Definition at line 4467 of file XChain_test.cpp.

@@ -290,7 +290,7 @@ Public Attributes
-

Definition at line 4286 of file XChain_test.cpp.

+

Definition at line 4298 of file XChain_test.cpp.

@@ -327,7 +327,7 @@ Public Attributes
-

Definition at line 4292 of file XChain_test.cpp.

+

Definition at line 4304 of file XChain_test.cpp.

@@ -363,7 +363,7 @@ Public Attributes
-

Definition at line 4303 of file XChain_test.cpp.

+

Definition at line 4315 of file XChain_test.cpp.

@@ -382,7 +382,7 @@ Public Attributes
-

Definition at line 4324 of file XChain_test.cpp.

+

Definition at line 4336 of file XChain_test.cpp.

@@ -402,7 +402,7 @@ Public Attributes
-

Definition at line 4367 of file XChain_test.cpp.

+

Definition at line 4379 of file XChain_test.cpp.

@@ -438,7 +438,7 @@ Public Attributes
-

Definition at line 4373 of file XChain_test.cpp.

+

Definition at line 4385 of file XChain_test.cpp.

@@ -474,7 +474,7 @@ Public Attributes
-

Definition at line 4398 of file XChain_test.cpp.

+

Definition at line 4410 of file XChain_test.cpp.

@@ -510,7 +510,7 @@ Public Attributes
-

Definition at line 4411 of file XChain_test.cpp.

+

Definition at line 4423 of file XChain_test.cpp.

@@ -540,7 +540,7 @@ Public Attributes
-

Definition at line 4418 of file XChain_test.cpp.

+

Definition at line 4430 of file XChain_test.cpp.

@@ -559,7 +559,7 @@ Public Attributes
-

Definition at line 4424 of file XChain_test.cpp.

+

Definition at line 4436 of file XChain_test.cpp.

@@ -576,7 +576,7 @@ Public Attributes
-

Definition at line 4457 of file XChain_test.cpp.

+

Definition at line 4469 of file XChain_test.cpp.

@@ -592,7 +592,7 @@ Public Attributes
-

Definition at line 4458 of file XChain_test.cpp.

+

Definition at line 4470 of file XChain_test.cpp.

@@ -608,7 +608,7 @@ Public Attributes
-

Definition at line 4459 of file XChain_test.cpp.

+

Definition at line 4471 of file XChain_test.cpp.

@@ -624,7 +624,7 @@ Public Attributes
-

Definition at line 4460 of file XChain_test.cpp.

+

Definition at line 4472 of file XChain_test.cpp.

@@ -640,7 +640,7 @@ Public Attributes
-

Definition at line 4461 of file XChain_test.cpp.

+

Definition at line 4473 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1BridgeCounters.html b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1BridgeCounters.html index d8231a6ba7..dfee87bb38 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1BridgeCounters.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1BridgeCounters.html @@ -108,7 +108,7 @@ Public Attributes

Detailed Description

-

Definition at line 4432 of file XChain_test.cpp.

+

Definition at line 4444 of file XChain_test.cpp.

Member Typedef Documentation

◆ complete_cb

@@ -122,7 +122,7 @@ Public Attributes
-

Definition at line 4435 of file XChain_test.cpp.

+

Definition at line 4447 of file XChain_test.cpp.

@@ -139,7 +139,7 @@ Public Attributes
-

Definition at line 4437 of file XChain_test.cpp.

+

Definition at line 4449 of file XChain_test.cpp.

@@ -155,7 +155,7 @@ Public Attributes
-

Definition at line 4438 of file XChain_test.cpp.

+

Definition at line 4450 of file XChain_test.cpp.

@@ -173,7 +173,7 @@ Public Attributes Initial value:
{
0}
-

Definition at line 4439 of file XChain_test.cpp.

+

Definition at line 4451 of file XChain_test.cpp.

@@ -189,7 +189,7 @@ Public Attributes
-

Definition at line 4443 of file XChain_test.cpp.

+

Definition at line 4455 of file XChain_test.cpp.

@@ -205,7 +205,7 @@ Public Attributes
-

Definition at line 4444 of file XChain_test.cpp.

+

Definition at line 4456 of file XChain_test.cpp.

@@ -221,7 +221,7 @@ Public Attributes
-

Definition at line 4445 of file XChain_test.cpp.

+

Definition at line 4457 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1Claims.html b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1Claims.html index 6209438849..345ff1e65e 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1Claims.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTrack_1_1Claims.html @@ -94,7 +94,7 @@ Public Attributes

Detailed Description

-

Definition at line 4448 of file XChain_test.cpp.

+

Definition at line 4460 of file XChain_test.cpp.

Member Data Documentation

◆ xfer_claims

@@ -108,7 +108,7 @@ Public Attributes
-

Definition at line 4450 of file XChain_test.cpp.

+

Definition at line 4462 of file XChain_test.cpp.

@@ -124,7 +124,7 @@ Public Attributes
-

Definition at line 4451 of file XChain_test.cpp.

+

Definition at line 4463 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTracker.html b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTracker.html index abda552785..5c51a13674 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTracker.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1ChainStateTracker.html @@ -151,7 +151,7 @@ Public Attributes

Detailed Description

-

Definition at line 4464 of file XChain_test.cpp.

+

Definition at line 4476 of file XChain_test.cpp.

Constructor & Destructor Documentation

◆ ChainStateTracker()

@@ -179,7 +179,7 @@ Public Attributes
-

Definition at line 4466 of file XChain_test.cpp.

+

Definition at line 4478 of file XChain_test.cpp.

@@ -199,7 +199,7 @@ Public Attributes
-

Definition at line 4471 of file XChain_test.cpp.

+

Definition at line 4483 of file XChain_test.cpp.

@@ -218,7 +218,7 @@ Public Attributes
-

Definition at line 4477 of file XChain_test.cpp.

+

Definition at line 4489 of file XChain_test.cpp.

@@ -238,7 +238,7 @@ Public Attributes
-

Definition at line 4484 of file XChain_test.cpp.

+

Definition at line 4496 of file XChain_test.cpp.

@@ -255,7 +255,7 @@ Public Attributes
-

Definition at line 4490 of file XChain_test.cpp.

+

Definition at line 4502 of file XChain_test.cpp.

@@ -271,7 +271,7 @@ Public Attributes
-

Definition at line 4491 of file XChain_test.cpp.

+

Definition at line 4503 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChainSim__test_1_1Transfer.html b/structripple_1_1test_1_1XChainSim__test_1_1Transfer.html index 7d85c6eb59..1b6840d199 100644 --- a/structripple_1_1test_1_1XChainSim__test_1_1Transfer.html +++ b/structripple_1_1test_1_1XChainSim__test_1_1Transfer.html @@ -123,7 +123,7 @@ Public Attributes

Detailed Description

-

Definition at line 4230 of file XChain_test.cpp.

+

Definition at line 4242 of file XChain_test.cpp.

Member Data Documentation

◆ from

@@ -137,7 +137,7 @@ Public Attributes
-

Definition at line 4232 of file XChain_test.cpp.

+

Definition at line 4244 of file XChain_test.cpp.

@@ -153,7 +153,7 @@ Public Attributes
-

Definition at line 4233 of file XChain_test.cpp.

+

Definition at line 4245 of file XChain_test.cpp.

@@ -169,7 +169,7 @@ Public Attributes
-

Definition at line 4234 of file XChain_test.cpp.

+

Definition at line 4246 of file XChain_test.cpp.

@@ -185,7 +185,7 @@ Public Attributes
-

Definition at line 4235 of file XChain_test.cpp.

+

Definition at line 4247 of file XChain_test.cpp.

@@ -201,7 +201,7 @@ Public Attributes
-

Definition at line 4236 of file XChain_test.cpp.

+

Definition at line 4248 of file XChain_test.cpp.

@@ -217,7 +217,7 @@ Public Attributes
-

Definition at line 4237 of file XChain_test.cpp.

+

Definition at line 4249 of file XChain_test.cpp.

@@ -233,7 +233,7 @@ Public Attributes
-

Definition at line 4238 of file XChain_test.cpp.

+

Definition at line 4250 of file XChain_test.cpp.

@@ -249,7 +249,7 @@ Public Attributes
-

Definition at line 4239 of file XChain_test.cpp.

+

Definition at line 4251 of file XChain_test.cpp.

diff --git a/structripple_1_1test_1_1XChain__test.html b/structripple_1_1test_1_1XChain__test.html index 2db62d5314..790993f0aa 100644 --- a/structripple_1_1test_1_1XChain__test.html +++ b/structripple_1_1test_1_1XChain__test.html @@ -396,7 +396,7 @@ Static Public Attributes

Commit to sidechain door accounts: | bridge spec | result case 6 | A -> B | B's balance increase case 7 | C <- A | A's balance increase

We also test ModifyBridge txns modify correct bridges.

-

Definition at line 558 of file XChain_test.cpp.

+

Definition at line 559 of file XChain_test.cpp.

@@ -415,7 +415,7 @@ Static Public Attributes
-

Definition at line 678 of file XChain_test.cpp.

+

Definition at line 690 of file XChain_test.cpp.

@@ -435,7 +435,7 @@ Static Public Attributes

test tfClearAccountCreateAmount flag in BridgeModify tx – tx has both minAccountCreateAmount and the flag, temMALFORMED – tx has the flag and also modifies signature reward, tesSUCCESS – XChainCreateAccountCommit tx fail after previous step

-

Definition at line 970 of file XChain_test.cpp.

+

Definition at line 982 of file XChain_test.cpp.

@@ -454,7 +454,7 @@ Static Public Attributes
-

Definition at line 1277 of file XChain_test.cpp.

+

Definition at line 1289 of file XChain_test.cpp.

@@ -473,7 +473,7 @@ Static Public Attributes
-

Definition at line 1367 of file XChain_test.cpp.

+

Definition at line 1379 of file XChain_test.cpp.

@@ -492,7 +492,7 @@ Static Public Attributes
-

Definition at line 1503 of file XChain_test.cpp.

+

Definition at line 1515 of file XChain_test.cpp.

@@ -514,7 +514,7 @@ Static Public Attributes

Good cases: –G1: master key –G2: regular key –G3: public key and non-exist (unfunded) account match

Bad cases: –B1: disabled master key –B2: single item signer list –B3: public key and non-exist (unfunded) account mismatch –B4: not on signer list –B5: missing sfAttestationSignerAccount field

-

Definition at line 2376 of file XChain_test.cpp.

+

Definition at line 2388 of file XChain_test.cpp.

@@ -533,7 +533,7 @@ Static Public Attributes
-

Definition at line 2605 of file XChain_test.cpp.

+

Definition at line 2617 of file XChain_test.cpp.

@@ -552,7 +552,7 @@ Static Public Attributes
-

Definition at line 2680 of file XChain_test.cpp.

+

Definition at line 2692 of file XChain_test.cpp.

@@ -571,7 +571,7 @@ Static Public Attributes
-

Definition at line 3936 of file XChain_test.cpp.

+

Definition at line 3948 of file XChain_test.cpp.

@@ -590,7 +590,7 @@ Static Public Attributes
-

Definition at line 4101 of file XChain_test.cpp.

+

Definition at line 4113 of file XChain_test.cpp.

@@ -609,7 +609,7 @@ Static Public Attributes
-

Definition at line 4151 of file XChain_test.cpp.

+

Definition at line 4163 of file XChain_test.cpp.

@@ -636,7 +636,7 @@ Static Public Attributes
-

Definition at line 4201 of file XChain_test.cpp.

+

Definition at line 4213 of file XChain_test.cpp.