理解加密货币的基石：代币经济学

想在加密货币的世界里分一杯羹？那你绝对不能忽略“代币经济学”。它就像是游戏规则，决定着一个加密货币项目的命运。理解了它，你才能更好地评估一个项目的潜力，避免踩坑。

本文将带你深入了解代币经济学的核心概念，以及它在实际应用中的例子。我们还会以Solana为例，剖析它背后的经济模型。

什么是代币经济学？

简单来说，代币经济学就是研究加密货币经济运行规律的学问。它涵盖了代币的方方面面，从发行量和分配方式，到它的实际用途和市场流通性，都包含在内。一个简单的道理：如果一个代币用处广泛，而且它的生态系统蓬勃发展，那它的价值自然水涨船高；反之，如果用处有限，市场又饱和了，价值就会下跌。这就像一个商品的供需关系，只不过这商品是数字化的。

代币经济学的目的

研究代币经济学能帮助我们做到以下几点：

1. 预测项目前景：通过分析代币的供需关系，我们可以预测它的长期价值。
2. 调节代币稀缺性：合理的代币分配和销毁机制，可以有效控制代币的稀缺程度，从而影响其价值。
3. 增强网络安全性： 一个设计良好的代币经济学模型，能够激励用户积极参与，从而保证项目的长期稳定运行。

但这并不是代币经济学的全部，它还涉及更多更复杂的因素，我们接下来会详细探讨。

代币经济学的主要构成要素

代币经济学就像一个精密的仪器，由多个关键部件构成，它们共同决定着加密货币项目的成败。这些部件包括：

• 总供应量:未来将发行的代币总数。有些项目是通缩的，总量有限（比如比特币）；有些则是通胀的，会不断发行新代币。这直接影响到代币的稀缺性。
• 分配方式: 代币如何分配给项目团队、投资者和社区。公平的分配有助于防止权力过于集中。
• 代币用途:代币在项目生态系统中的作用，例如支付交易费用、参与治理或作为价值存储。用途越广泛，需求就越高。
• 奖励机制:激励用户参与网络的机制，例如质押奖励或挖矿奖励。这能保证网络的长期健康发展。
• 治理机制:如何进行决策，例如代币持有者投票决定项目发展方向。
• 销毁机制:一些项目会定期销毁一部分代币，以减少总供应量，提高剩余代币的价值。
• 流动性:代币在市场上的交易活跃程度。流动性越高，价格波动越小，交易越方便。

Solana (SOL) 代币经济学案例分析

Solana 的代币经济学设计堪称典范，它巧妙地将各个要素结合起来，促进了生态系统的繁荣和SOL代币的增长。让我们来看看它的具体做法：

• 总供应量:SOL 的初始总供应量为5亿，但会随着时间的推移而增加，但通胀率会逐渐降低。
• 分配方式:代币分配给团队、投资者和社区，比例相对均衡。
• 代币用途:SOL 可用于支付交易费用、参与治理、质押获得奖励等。
• 奖励机制:通过质押机制奖励验证者和代币持有者。
• 治理机制:SOL 持有者可以参与治理投票。
• 销毁机制:部分交易费用会被销毁。
• 流动性:SOL 在各大交易平台都有上市，流动性极佳。

总而言之，代币经济学是理解加密货币项目的关键。深入研究一个项目的代币经济学，能帮助你更好地判断其投资价值，避免踩坑。希望这篇文章能帮助你更好地理解这个重要的概念。 还有疑问？欢迎留言讨论！

ZKThreads：构建可扩展安全去中心化应用的新框架

去中心化应用（DApps）高效运行的关键在于安全性、组合性和互操作性，但这三者往往难以兼顾。ZKThreads 为此提供了一种潜在的解决方案。它是一个零知识框架，能够显著提升去中心化应用的性能和可扩展性。

ZKThreads 的工作原理：

首先，应用逻辑部署到 ZKThreads 的应用合约中。这些合约定义了应用的运行规则和流程。然后，ZKThreads 将多个交易批量处理，而不是逐个处理，提高了效率。接下来，系统会生成一个 STARK 证明，以确保批量交易的有效性及流程符合合约规则。最后，这个 STARK 证明会被发送到 Layer 2 协调器进行验证，验证过程会检查是否存在重复花费、所有交易是否获得授权以及最终状态是否与区块链规则一致。如果证明有效，则更新 DApp 的规范状态记录；反之，则拒绝更改，确保应用的完整性。

ZKThreads 与其他零知识解决方案的差异：

ZKThreads 将状态和交易数据都存储在链下，并利用零知识证明 (ZKPs) 来验证交易。这与许多传统的零知识汇总 (zk-rollups) 不同，后者虽然将计算转移到链下，但仍将交易数据存储在链上。链下存储数据显著降低了主区块链的数据负载，从而提高了可扩展性和降低了成本。而 zk-rollups（例如 zkSync）则定期将批量交易数据发布到链上，以确保基础层的数据可用性。

在互操作性方面，ZKThreads 优先考虑可互操作的应用，减少碎片化，并确保不同的 DApps 能够在同一生态系统中无缝交互。相比之下，其他解决方案（如 zkEVM）更侧重于兼容性。

验证机制方面，ZKThreads 使用 STARK 证明来验证批量交易和状态更改的正确性，然后将这些证明与 DApp 的规范状态进行验证。而一些 zk-rollups（如 zkSync）则使用 zk-SNARKs 或 zk-STARKs 生成加密证明，并在链上进行验证。

ZKThreads 的优势：

• 提升用户体验： ZKThreads 允许不同 DApps 之间无缝交互，用户无需切换网络即可访问多个应用。
• 降低成本： 通过批量处理交易，ZKThreads 减少了需要记录在主区块链上的交易数量，降低了用户的交易费用。此外，链下存储数据也降低了 Gas 费。
• 增强安全性： ZKThreads 利用 ZKPs 来增强安全性，在验证交易的同时保护数据隐私，并防止未经授权的活动。

ZKThreads 的应用案例：

• Layer 2 去中心化交易所 (DEX)： ZKThreads 可以通过降低用户的交易费用，使 Starknet 上的 DEX 更高效。
• 基于会话的游戏： 在扑克和象棋等基于会话的游戏中，ZKThreads 可以帮助汇总费用，玩家只需在游戏结束时支付一次费用。
• 零知识安全中间件和共享流动性基础设施： ZKThreads 为中间件应用（如预言机和跨链桥）提供安全高效的框架。
• 链上 AI： ZKThreads 提供了足够的计算能力，可以直接在区块链上运行 AI 模型。

总结：

ZKThreads 是一个使用 ZKPs 构建可扩展和安全 DApps 的框架，可用于 Starknet DEX、基于会话的游戏和中间件应用。与其他零知识解决方案不同，ZKThreads 强调互操作性，将所有数据存储在链下，并采用不同的验证机制。展望未来，ZKThreads 有潜力显著提升 DApps 的性能和可用性。 它为构建更强大、更具扩展性和更安全的去中心化生态系统提供了新的可能。

了解lumn股票及其相关知识

大家好，今天我将为大家介绍lumn股票，并分享一些与lu股票怎么样相关的知识点。很多人可能对此不太了解，接下来我将详细解答。

MACD的背离是什么？

简单地说，MACD的背离就是指标值的方向与股价的方向相反，就产生了背离。看文字可能不太直观，看图就非常明显了。有DIF值背离、DEA值背离和MACD柱背离。很多人喜欢用MACD背离分析股票，回测一下数据就知道了。

下面是MACD底背离选股公式的近两年和全部历史时段的胜率回测。

Oracle通用函数、分组函数、子查询

注意：Oracle中的字符串是严格区分大小写的，日期和字符只能在单引号中出现。

把列与列、列与字符连接在一起用 || 符号。

列的别名紧跟列名，也可以在列名和别名之间加入关键字AS。为了在别名中包含空格或特殊的字符并区分大小写，可以使用双引号。

例子：

SELECT last_name || 'is a' || job_id AS "Employee Details"

FROM employees

where first_name like '%s_';

通用函数：

空值是无效的、未指定的、未知的或不可预知的值。空值不是空格，包含空值的数学表达式的值都为空值。

这些函数适用于任何数据类型，同时也适用于空值：

• NVL (expr1, expr2)
• NVL2 (expr1, expr2, expr3)
• NULLIF (expr1, expr2)
• COALESCE (expr1, expr2, ..., exprn)

NVL (expr1, expr2)：如果expr1为NULL，返回expr2；否则返回expr1。注意两者的类型要一致。

NVL2 (expr1, expr2, expr3)：如果expr1不为NULL，返回expr2；否则返回expr3。如果expr2和expr3类型不同，expr3会转换为expr2的类型。

NULLIF (expr1, expr2)：如果expr1和expr2相等，返回NULL；否则返回expr1。

COALESCE(expr1, expr2, ..., exprn)：列表中第一个非空的表达式是函数的返回值。如果所有的表达式都是空值，最终将返回一个空值。

条件表达式在SQL语句中使用IF-THEN-ELSE逻辑。可以使用两种方法：

• CASE表达式：CASE expr WHEN comparison_expr1 THEN return_expr1 [WHEN comparison_expr2 THEN return_expr2 ... WHEN comparison_exprn THEN return_exprn ELSE else_expr] END
• DECODE函数：DECODE ( col | expression , search1, result1 [, search2, result2 ...][, default] )

分组函数：

分组函数作用于一组数据，并对一组数据返回一个值。

组函数语法：

SELECT [column,] group_function(column)

FROM table

[WHERE condition]

[GROUP BY column]

[ORDER BY column];

注意：在SELECT列表中，所有未包含在组函数中的列都应该包含在GROUP BY子句中。包含在GROUP BY子句中的列不必包含在SELECT列表中。可以在GROUP BY子句中包含多个列。不能在WHERE子句中使用组函数，但可以在HAVING子句中使用组函数。

使用HAVING过滤分组：

行已经被分组，使用了组函数，满足HAVING子句中条件的分组将被显示。

SELECT column, group_function

FROM table

[WHERE condition]

[GROUP BY group_by_expression]

[HAVING group_condition]

[ORDER BY column];

子查询：

语法：

SELECT select_list

FROM table

WHERE expr operator

(SELECT select_list

FROM table);

注意：子查询（内查询）在主查询之前一次执行完成。子查询的结果被主查询使用（外查询）。子查询要包含在括号内。将子查询放在比较条件的右侧。除非进行Top N 分析，否则不要在子查询中使用ORDER BY子句。单行操作符对应单行子查询，多行操作符对应多行子查询。

单行操作符operator：多行操作符operator：

• = 等于 IN 等于列表中的任何一个
• \> 大于 ANY 和子查询返回的任意一个值比较
• \>= 大于等于 ALL 和子查询返回的所有值比较
• < 小于 EXISTS 功能等价于IN
• <= 小于等于
• != 不等于

DECODE和CASE：SELECT中除GROUP BY子句以外的所有子句中，都可以使用单行子查询。

在子查询中使用HAVING子句：

SELECT select_list

FROM table

[GROUP BY group_by_expression]

[HAVING group_condition] expr operator

(SELECT select_list

FROM table);

在FROM子句中使用子查询：

例子：

SELECT a.last_name, a.salary, a.department_id, b.salavg

FROM employees a, (SELECT department_id, AVG(salary) salavg

FROM employees

GROUP BY department_id) b

WHERE a.department_id = b.department_id

AND a.salary>b.salavg;

有两个简单例子，以说明EXISTS和IN的效率问题：

1) SELECT * FROM T1 WHERE EXISTS(SELECT * FROM T2 WHERE T1.a=T2.a);

T1数据量小而T2数据量非常大时(T1

2) SELECT * FROM T1 WHERE T1.a IN (SELECT T2.a FROM T2);

T1数据量非常大而T2数据量小时(T1>T2时)，IN()的查询效率高。

EXISTS用法：

请注意，句中的有颜色字体的部分，理解其含义。

其中 SELECT * FROM T2 WHERE T1.a=T2.a 相当于一个关联表查询，相当于

SELECT * FROM T1, T2 WHERE T1.a=T2.a

但是，如果你当当执行1)句括号里的语句，是会报语法错误的，这也是使用EXISTS需要注意的地方。

EXISTS（xxx）就表示括号里的语句能不能查出记录，它要查的记录是否存在。

因此，SELECT这里的*其实是无关紧要的，换成*也没问题，它只在乎括号里的数据能不能查找出来，是否存在这样的记录。如果存在，这1)句的WHERE条件成立。

IN的用法：

继续引用上面的例子：

2) SELECT * FROM T1 WHERE T1.a IN (SELECT T2.a FROM T2)

这里的IN后面括号里的语句搜索出来的字段的内容一定要相对应，一般来说T1和T2这两个表的a字段表达的意义应该是一样的，否则这样查没什么意义。

打个比方，T1、T2表都有一个字段，表示工单号。但是T1表示工单号的字段名叫ticketid，T2则为id，但是其表达的意义是一样的，而且数据格式也是一样的。这时，用2)的写法就可以这样：

SELECT * FROM T1 WHERE T1.ticketid IN (SELECT T2.id FROM T2)

EXISTS操作符：

EXISTS 操作符检查在子查询中是否存在满足条件的行。

如果在子查询中存在满足条件的行：

• 不在子查询中继续查找
• 条件返回TRUE

如果在子查询中不存在满足条件的行：

• 条件返回FALSE
• 继续在子查询中查找

相关子查询：

相关子查询按照一行接一行的顺序执行，主查询的每一行都执行一次子查询。子查询使用了主查询中的列。

SELECT column1, column2

FROM table outer

WHERE columnk operator (SELECT column1, column2

FROM table

WHERE expr= outer.expr);

相关更新：

使用相关子查询依据一个表中的数据更新另一个表的数据。

UPDATE table alias

SET column = (SELECT expression

FROM table alias

WHERE column1 = column1);

相关删除：

使用相关子查询依据一个表中的数据删除另一个表的数据。

DELETE FROM table alias

WHERE column operator (SELECT expression

FROM table alias

WHERE column1 = column1);

WITH子句：

使用WITH子句，可以避免在SELECT语句中重复书写相同的语句块。

WITH子句将该子句中的语句块执行一次，并存储到用户的临时表空间中。

使用WITH子句可以提高查询效率。

我们可以使用WITH Clause来定义一个query block，然后在SELECT statement的其它地方使用这个query block。如果在一个很复杂的Query里，我们必须重复地使用某个subquery，那么使用WITH Clause可以降低Query的复杂度以及提高performance，因为WITH Clause所读出的资料会暂存在User的temporary tablespace中。

WITH子句应用举例：

WITH

dept_costs AS (SELECT d.department_name, SUM(e.salary) AS dept_total

FROM employees e, departments d

WHERE e.department_id = d.department_id

GROUP BY d.department_name),

avg_cost AS (SELECT SUM(dept_total)/COUNT(*) AS dept_avg

FROM dept_costs)

SELECT *

FROM dept_costs

WHERE dept_total>(SELECT dept_avg

FROM avg_cost)

ORDER BY department_name;

GROUP BY 扩展：

带有ROLLUP和CUBE操作的GROUP BY子句：

使用带有ROLLUP和CUBE操作的GROUP BY子句产生多种分组结果。

ROLLUP产生n + 1 种分组结果，其是对GROUP BY子句的扩展。

CUBE产生2的n次方种分组结果，其是对GROUP BY子句的扩展。

注：其中的n指的是group_by_expression的数目。

ROLLUP操作符：ROLLUP产生n + 1 种分组结果，顺序是从右向左。

SELECT [column,] group_function(column)

FROM table

[WHERE condition]

[GROUP BY [ROLLUP] group_by_expression]

[HAVING having_expression]

[ORDER BY column];

CUBE操作符：CUBE会产生类似于笛卡尔集的分组结果。

SELECT [column,] group_function(column)

FROM table

[WHERE condition]

[GROUP BY [CUBE] group_by_expression]

[HAVING having_expression]

[ORDER BY column];

GROUPING函数：能够实现更加直观的分组结果显示提示。

SELECT [column,] group_function(column) [, GROUPING(group_by_expression)]

FROM table

[WHERE condition]

[GROUP BY [ROLLUP] [CUBE] group_by_expression]

[HAVING having_expression]

[ORDER BY column];

GROUPING函数可以和CUBE或ROLLUP结合使用。

使用GROUPING函数，可以找到哪些列在该行中参加了分组。

使用GROUPING函数，可以区分空值产生的原因。

GROUPING函数返回0 或 1。

GROUPING SETS：

GROUPING SETS是对GROUP BY子句的进一步扩充。

使用GROUPING SETS可以实现在同一个查询中定义多个分组集。

Oracle 对GROUPING SETS子句指定的分组集进行分组后，用UNION ALL操作将各分组结果结合起来。

Grouping set 的优点：

• 只进行一次分组即可
• 不必书写复杂的UNION语句
• GROUPING SETS中包含的分组项越多，性能越好

以下例子实现了对department_id, job_id分组，对job_id, manager_id分组，最终形成两个分组：

SELECT department_id, job_id, manager_id, avg(salary)

FROM employees

GROUP BY GROUPING SETS ((department_id, job_id), (job_id, manager_id));

复合列：

复合列是被作为整体处理的一组列的集合。

使用括号将若干列组成复合列，在ROLLUP或CUBE中作为整体进行操作。

在ROLLUP或CUBE中，复合列可以避免产生不必要的分组结果。

例如：GROUP BY ROLLUP( department_id, (job_id, manager_id)); //小括号实现复合列

连接分组集：

连接分组集可以产生有用的对分组项的结合。

将各分组集ROLLUP和CUBE用逗号连接，Oracle自动在GROUP BY子句中将各分组集进行连接。

连接的结果是对各分组生成笛卡尔集。

例如：GROUP BY GROUPING SETS(a, b), GROUPING SETS(c, d);

跟我学SQL：查询多个表格

在对跨多个表格的数据进行组合时，有时很难搞清楚要使用哪一个SQL句法。我将在这里对将多个表格中的查询合并至单一声明中的常用方式进行阐述。在这篇文章中的样本查询符合SQL ISO标准。不是所有的数据库生产商都遵循这项标准，而且很多厂商采取的提升措施会带来一些意料不到的后果。如果你不确定你的数据库是不是支持这些标准，你可以参看生产厂商的有关资料。

SELECT：一个简单的SELECT声明就是查询多个表格的最基本的方式。你可以在FROM子句中调用多个表格来组合来自多个表格的结果。这是一个它如何工作的实例：

SELECT table1.column1, table2.column2 FROM table1, table2 WHERE table1.column3 = table2.column3 ;

这个实例中，我使用点号(table1.column1)来指定专栏来自哪一个表格。如果所涉及的专栏只在一个参考的表格中出现，你就不需要加入完整的名称，但是加入完整名称会对可读性起到帮助。在FROM子句中表格之间由逗号来分隔。你可以加入所需的任意多的表格，尽管一些数据库有一个在引入正式的JOIN声明之前他们可以有效地处理的内容这方面的限制，这个将在下面谈到。这个句法是一个简单的INNER JOIN，一些数据库将它看成与一个外部的JOIN是等同的。WHERE子句告知数据库哪一个区域要做关联，而且它返回结果时，就像列出的表格在给定的条件下组合成一个单独的表格一样。

值得注意的是，你的比较条件并不需要与你作为结果组返回的专栏相同。在上面的例子中，table1.column3和table2.column3用来组合表格，但是返回的却是table1.column1。你可以在WHERE子句中使用AND关键字来将这个功能扩展至多于两个的表格。你还可以使用这样的表格组合来限制你的结果而不用实际地从每个表格返回专栏。在下面的例子中，table3与table1匹配，但是我没有从table3返回任何东西来显示，我只是确保来自table3的有关专栏存在于table1之中。注意此例中table3需要在FROM子句中被引用：

SELECT table1.column1, table2.column2 FROM table1, table2, table3 WHERE table1.column3 = table2.column3 AND table1.column4 = table3.column4 ;

然而，要注意的是，这个查询多个表格的方式是一个暗指的JOIN，你的数据库可能对事物进行不同的处理，这取决于它所使用的优化引擎。而且，忽略对与WHERE子句的相关特性的定义将会给你带来不愿看到的结果，例如从余下的查询中返回与每一个可能的结果相关的专栏的rogue域，就像在CROSS JOIN之中一样。如果你习惯于你的数据库处理这种类型的声明的方式，且你只对两个或是少数几个表格进行组合，一个简单的SELECT声明就可以达到目的。

JOIN：JOIN的工作方式与SELECT声明是相同的，它从不同的表格中返回一个带有专栏的结果组。在暗含的JOIN之上使用外部JOIN的优势是对你的结果组的更好的控制，而且还可能在涉及很多个表格的情况下提升性能表现。JOIN的类型有几种：LEFT、RIGHT、FULL、OUTER、INNER和CROSS。你所使用的类型是由你想要看到的结果所决定的。例如，使用LEFT OUTER JOIN将会从列出的第一个表格中返回所有有关的行，而同时如果没有信息与第一个表格相关的话将潜在地从所列出的第二个表格中加入行。在这里INNER JOIN和暗含的JOIN是不同的，INNER JOIN将只返回那些在两个表格中都有数据的行。对第一个SELECT查询使用如下JOIN声明：

SELECT table1.column1, table2.column2 FROM table1 INNER JOIN table2 ON table1.column3 = table2.column3 ;

子查询：子查询，或叫子选择声明，是在一个查询中将结果组作为资源使用的一个途径。他经常被用来对结果进行限制或定义，而不是运行多个查询或操纵应用软件之中的数据。有了子查询，你可以参考表格来决定数据的内含，或是在一些情况下，返回一个专栏，而这个专栏是一个子选择的结果。下面的例子中使用了两个表格，一个表格中包含了我想要返回的数据，而另一个表格则给出一个比较点来确定什么数据是我确实感兴趣的：

SELECT column1 FROM table1 WHERE EXISTS ( SELECT column2 FROM table2 WHERE table1.column3 = table2.column3 );

子查询很重要的一个方面就是性能表现。便利性是有代价的。它取决于你所使用的表格和声明的大小、数量和复杂性，还有你可能会允许你的应用软件做处理工作。每一个查询在被主查询作为资源使用之前，都将被完整地单独处理。如果可能的话，创造性地使用JOIN声明可以以较少的滞后时间提供出相同的信息。

FreeMarker的标记语法

借Struts核心jar包下的Filter包的error.ftl文件来学习一下FreeMarker的标记语法。

该ftl模板（error.ftl）用于指示开发者Struts页面请求出错后，指定转向该模板所生成的静态页面。

\*

\* $Id: error.ftl,v 1.1 2007/11/05 21:42:24 rachel Exp $

\*

\* Licensed to the Apache Software Foundation (ASF) under one

\* or more contributor license agreements. See the NOTICE file

\* distributed with this work for additional information

\* regarding copyright ownership. The ASF licenses this file

\* to you under the Apache License, Version 2.0 (the

\* "License"); you may not use this file except in compliance

\* with the License. You may obtain a copy of the License at

\*

\*

\*

\* Unless required by applicable law or agreed to in writing,

\* software distributed under the License is distributed on an

\* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

\* KIND, either express or implied. See the License for the

\* specific language governing permissions and limitations

\* under the License.

\*/

Struts Problem Report

pre {

margin: 0;

padding: 0;

}

Struts Problem Report

Struts has detected an unhandled exception:

\#assign msgs = [] /

\#list chain as ex

\#if ex.message??

\#assign msgs = [ex.message] + msgs/

\#/if

\#list

\#assign rootex = exception/

\#list chain as ex

\#if (ex.location?? && (ex.location != "unknown"))

\#assign rootloc = ex.location/

\#assign rootex = ex/

\#else

\#assign tmploc = locator.getLocation(ex) /

\#if (tmploc != "unknown")

\#assign rootloc = tmploc/

\#assign rootex = ex/

\#/if

\#/if

\#list

Messages:/strong:

\#if (msgs?size)

\#list msgs as msg

\#if (msg?is_method)

li${msg[0]}/li

\#else

li${msg}/li

\#/if

\#list

\#elseif (msgs?size == 0)

\#if (msgs[0]?is_method)

li${msgs[0][0]}/li

\#else

li${msgs[0]}/li

\#/if

\#/if

\#if rootloc??

File:/strong:

${rootloc.URI}

Line number:/strong:

${rootloc.lineNumber}

\#if (columnNumber > 0)

Column number:/strong:

${columnNumber}

\#/if

\#/if

\#if rootloc??

\#assign snippet = rootloc.getSnippet() /

\#if (snippet?size)

\#list snippet as line

\#if (line_index == 0)

\#if (columnNumber > 0)

${(line[0..(columnNumber-1)]?)}${(line[(columnNumber-1)..(columnNumber-1)]?)}

\#if ((columnNumber)0)}${(line[(columnNumber)..(line?length-1)]?)}/#if

\#else

${line?}

\#/if

\#else

${line?}

\#/if

\#list

\#/if

\#/if

Stacktraces

\#list chain as ex

${ex}

\#list ex.stackTrace as frame

${frame}

\#list

\#list

You are seeing this page because development mode is enabled. Development mode or devMode enables extra

debugging behaviors and reports to assist developers. To disable this mode set:

struts.devMode=false

in your codeWEB-INF/classes/struts.properties code file

• 

  ChainLink暴跌是什么原因

  2个月前

  点击查看
• 

  BCH跑路了吗

  2个月前

  点击查看
• 

  Gemini下载指南：安全交易从这里开始

  2个月前

  点击查看
• 

  USDC浏览器是干什么的

  2个月前

  点击查看
• 

  PERP币长期持有价值分析

  2个月前

  点击查看
• 

  OK币区块中文查到的真实吗

  2个月前

  点击查看