@pushchain/core 6.0.21 → 6.0.23

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+@pushchain/core@6.0.23 (2026-09-01)
+
+- docs: changelog entry for the EVM PC20 burn routing fix
+- fix: route EVM PC20 imports through the payload path
+
+---
+
+@pushchain/core@6.0.22 (2026-08-14)
+
+- fix: make PC20 first exports and Solana R3 E2E reliable
+- fix: support PC20 exports for standard ERC-20 tokens
+- feat: curated E2E CI suite with pre-flight fund gate
+
+---
+
 @pushchain/core@6.0.21 (2026-08-01)
 
 - fix: pc20 bug fix
@@ -11,8 +26,15 @@
 @pushchain/core@6.1.0 (unreleased)
 
 - Added first-class PC20 support to the universal transaction API. PC20 tokens
-  are resolved from their chain and address through UniversalCore, without an
-  explicit token-standard flag.
+  are identified by chain and address without an explicit token-standard flag.
+  External wrappers are resolved through UniversalCore, while Push-native
+  tokens are validated directly on Push Chain.
+
+- Removed the custom `pc20Metadata()` requirement for Push-native PC20 exports.
+  Any metadata-compatible ERC-20 born on Push Chain can now be exported: the SDK
+  reads the standard `name()`, `symbol()`, and `decimals()` functions, verifies
+  deployed bytecode, and continues to reject synthetic PRC20 addresses from the
+  PC20 path.
 
 - Added `PushChain.utils.tokens.getPC20Address()` for resolving either a
   Push-native PC20 or an external wrapper and listing its confirmed deployments.
@@ -40,10 +62,24 @@
   account as the gateway recipient instead of the zero address, preventing the
   forwarded funds leg from attempting to credit `address(0)`.
 
+- Fixed first PC20 wrapper deployments running out of gas on the destination.
+  The SDK now re-quotes UGPC with the resolved deployment-aware limit and writes
+  the corresponding explicit limit into the outbound request.
+
 - Realigned inbound protobuf fields with the chain, exposed PC20 inbound
   metadata, and added SVM remaining-account support required by the Solana
   gateway.
 
+- Fixed EVM PC20 wrapper burns destroying the wrapper without unlocking the
+  canonical token. A payload-less burn took the funds-only path, whose empty
+  payload gains the gateway's PC20 selector and then fails the chain's inbound
+  decode at ballot finalization — no handler runs, no revert is produced, and
+  the already-burned wrapper leaves the canonical token locked in VaultPC20.
+  The always-forward mitigation was gated to Solana; PC20 imports now route
+  through the payload path on both VMs, and `executeFundsOnly` fails closed
+  with `PC20UnsafeEmptyPayloadError` if a PC20 import ever reaches it again.
+  PRC20 and native funds-only flows are unchanged.
+
 ---
 
 @pushchain/core@6.0.20 (2026-07-10)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "6.0.21",
+  "version": "6.0.23",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",
@@ -50,7 +50,11 @@
     }
   },
   "scripts": {
-    "build:proto": "scripts/protoc-generate.sh"
+    "build:proto": "scripts/protoc-generate.sh",
+    "e2e:list": "ts-node --transpile-only __e2e__/ci/run.ts --list",
+    "e2e:verify": "ts-node --transpile-only __e2e__/ci/run.ts --verify",
+    "e2e:preflight": "ts-node --transpile-only __e2e__/ci/preflight.ts",
+    "e2e:ci": "ts-node --transpile-only __e2e__/ci/run.ts"
   },
   "type": "commonjs",
   "main": "./src/index.js",
@@ -67,7 +71,9 @@
   ],
   "devDependencies": {
     "@types/bs58": "^4.0.0",
+    "dotenv": "^16.4.5",
     "secp256k1": "^5.0.1",
+    "ts-node": "10.9.1",
     "ts-proto": "^2.0.3"
   }
 }

package/src/lib/constants/abi/erc20.evm.d.ts

@@ -1,4 +1,34 @@
 export declare const ERC20_EVM: readonly [{
+    readonly type: "function";
+    readonly name: "name";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
     readonly type: "function";
     readonly name: "balanceOf";
     readonly inputs: readonly [{

package/src/lib/constants/abi/erc20.evm.js

@@ -2,6 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERC20_EVM = void 0;
 exports.ERC20_EVM = [
+    {
+        type: 'function',
+        name: 'name',
+        inputs: [],
+        outputs: [{ name: '', type: 'string', internalType: 'string' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'symbol',
+        inputs: [],
+        outputs: [{ name: '', type: 'string', internalType: 'string' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'decimals',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint8', internalType: 'uint8' }],
+        stateMutability: 'view',
+    },
     {
         type: 'function',
         name: 'balanceOf',

package/src/lib/constants/abi/index.d.ts

@@ -12,6 +12,6 @@ export { CEA_FACTORY_EVM } from './ceaFactory.evm';
 export { UNIVERSAL_GATEWAY_PC } from './universalGatewayPC.evm';
 export { UNIVERSAL_CORE_EVM } from './prc20.evm';
 export { UEA_FACTORY_ABI } from './uea-factory';
-export { IPC20_EVM, PC20_FACTORY_EVM, PC20_WRAPPER_EVM, EXTERNAL_GATEWAY_PC20_EVM, VAULT_PC20_FACTORY_EVM, } from './pc20.evm';
+export { PC20_FACTORY_EVM, PC20_WRAPPER_EVM, EXTERNAL_GATEWAY_PC20_EVM, VAULT_PC20_FACTORY_EVM, } from './pc20.evm';
 export { WPC_EVM } from './wpc.evm';
 export { UNIV3_SWAP_ROUTER_EVM } from './uniswap-v3-router.evm';

package/src/lib/constants/abi/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNIV3_SWAP_ROUTER_EVM = exports.WPC_EVM = exports.VAULT_PC20_FACTORY_EVM = exports.EXTERNAL_GATEWAY_PC20_EVM = exports.PC20_WRAPPER_EVM = exports.PC20_FACTORY_EVM = exports.IPC20_EVM = exports.UEA_FACTORY_ABI = exports.UNIVERSAL_CORE_EVM = exports.UNIVERSAL_GATEWAY_PC = exports.CEA_FACTORY_EVM = exports.CEA_EVM = exports.SVM_GATEWAY_IDL = exports.ERC20_EVM = exports.UNIVERSAL_GATEWAY_V1_SEND = exports.UNIVERSAL_GATEWAY_V0 = exports.UEA_SVM = exports.UEA_EVM = exports.FACTORY_V1 = exports.FEE_LOCKER_SVM = exports.FEE_LOCKER_EVM = void 0;
+exports.UNIV3_SWAP_ROUTER_EVM = exports.WPC_EVM = exports.VAULT_PC20_FACTORY_EVM = exports.EXTERNAL_GATEWAY_PC20_EVM = exports.PC20_WRAPPER_EVM = exports.PC20_FACTORY_EVM = exports.UEA_FACTORY_ABI = exports.UNIVERSAL_CORE_EVM = exports.UNIVERSAL_GATEWAY_PC = exports.CEA_FACTORY_EVM = exports.CEA_EVM = exports.SVM_GATEWAY_IDL = exports.ERC20_EVM = exports.UNIVERSAL_GATEWAY_V1_SEND = exports.UNIVERSAL_GATEWAY_V0 = exports.UEA_SVM = exports.UEA_EVM = exports.FACTORY_V1 = exports.FEE_LOCKER_SVM = exports.FEE_LOCKER_EVM = void 0;
 const tslib_1 = require("tslib");
 var feeLocker_evm_1 = require("./feeLocker.evm");
 Object.defineProperty(exports, "FEE_LOCKER_EVM", { enumerable: true, get: function () { return feeLocker_evm_1.FEE_LOCKER_EVM; } });
@@ -33,7 +33,6 @@ var uea_factory_1 = require("./uea-factory");
 Object.defineProperty(exports, "UEA_FACTORY_ABI", { enumerable: true, get: function () { return uea_factory_1.UEA_FACTORY_ABI; } });
 // PC20
 var pc20_evm_1 = require("./pc20.evm");
-Object.defineProperty(exports, "IPC20_EVM", { enumerable: true, get: function () { return pc20_evm_1.IPC20_EVM; } });
 Object.defineProperty(exports, "PC20_FACTORY_EVM", { enumerable: true, get: function () { return pc20_evm_1.PC20_FACTORY_EVM; } });
 Object.defineProperty(exports, "PC20_WRAPPER_EVM", { enumerable: true, get: function () { return pc20_evm_1.PC20_WRAPPER_EVM; } });
 Object.defineProperty(exports, "EXTERNAL_GATEWAY_PC20_EVM", { enumerable: true, get: function () { return pc20_evm_1.EXTERNAL_GATEWAY_PC20_EVM; } });

package/src/lib/constants/abi/pc20.evm.d.ts

@@ -2,7 +2,6 @@
  * PC20 ABIs — minimal read surfaces for registry resolution and validation.
  *
  * Sources:
- *   IPC20            push-chain-gateway-contracts/contracts/evm-gateway/src/interfaces/IPC20.sol
  *   PC20Factory      push-chain-gateway-contracts/contracts/evm-gateway/src/PC20Factory.sol
  *   PC20Wrapper      push-chain-gateway-contracts/contracts/evm-gateway/src/PC20Wrapper.sol
  *   UniversalGateway push-chain-gateway-contracts/contracts/evm-gateway/src/UniversalGateway.sol
@@ -10,30 +9,6 @@
  * Read-only entries only. Writes go through the existing gateway ABIs — PC20
  * changes the payload, not the entrypoint.
  */
-/** Push-native token eligible for export. Presence of `pc20Metadata` IS the PC20 test. */
-export declare const IPC20_EVM: readonly [{
-    readonly type: "function";
-    readonly name: "pc20Metadata";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "name";
-        readonly type: "string";
-        readonly internalType: "string";
-    }, {
-        readonly name: "symbol";
-        readonly type: "string";
-        readonly internalType: "string";
-    }, {
-        readonly name: "decimals";
-        readonly type: "uint8";
-        readonly internalType: "uint8";
-    }, {
-        readonly name: "originAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}];
 /**
  * Destination-chain factory.
  *

package/src/lib/constants/abi/pc20.evm.js

@@ -3,7 +3,6 @@
  * PC20 ABIs — minimal read surfaces for registry resolution and validation.
  *
  * Sources:
- *   IPC20            push-chain-gateway-contracts/contracts/evm-gateway/src/interfaces/IPC20.sol
  *   PC20Factory      push-chain-gateway-contracts/contracts/evm-gateway/src/PC20Factory.sol
  *   PC20Wrapper      push-chain-gateway-contracts/contracts/evm-gateway/src/PC20Wrapper.sol
  *   UniversalGateway push-chain-gateway-contracts/contracts/evm-gateway/src/UniversalGateway.sol
@@ -12,22 +11,7 @@
  * changes the payload, not the entrypoint.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXTERNAL_GATEWAY_PC20_EVM = exports.VAULT_PC20_FACTORY_EVM = exports.PC20_WRAPPER_EVM = exports.PC20_FACTORY_EVM = exports.IPC20_EVM = void 0;
-/** Push-native token eligible for export. Presence of `pc20Metadata` IS the PC20 test. */
-exports.IPC20_EVM = [
-    {
-        type: 'function',
-        name: 'pc20Metadata',
-        inputs: [],
-        outputs: [
-            { name: 'name', type: 'string', internalType: 'string' },
-            { name: 'symbol', type: 'string', internalType: 'string' },
-            { name: 'decimals', type: 'uint8', internalType: 'uint8' },
-            { name: 'originAddress', type: 'address', internalType: 'address' },
-        ],
-        stateMutability: 'view',
-    },
-];
+exports.EXTERNAL_GATEWAY_PC20_EVM = exports.VAULT_PC20_FACTORY_EVM = exports.PC20_WRAPPER_EVM = exports.PC20_FACTORY_EVM = void 0;
 /**
  * Destination-chain factory.
  *

package/src/lib/orchestrator/cea-utils.js

@@ -36,6 +36,22 @@ function getViemChain(chain) {
     }
     return viemChain;
 }
+/**
+ * Transport for a CEAFactory read.
+ *
+ * `http(undefined)` falls back to the *viem* chain's default endpoint, which for
+ * `sepolia` is `https://sepolia.drpc.org` — a paid-plan host that answers every
+ * request with HTTP 400 ("chain is not available on free plan"). That silently
+ * broke every CEA derivation that did not pass an explicit rpcUrl, and no caller
+ * passes one. Use the SDK's own `CHAIN_INFO[].defaultRPC` list instead, wrapped in
+ * `fallback` so one dead endpoint rotates to the next.
+ */
+function ceaTransport(chain, rpcUrl) {
+    if (rpcUrl)
+        return (0, viem_1.http)(rpcUrl);
+    const rpcs = chain_1.CHAIN_INFO[chain]?.defaultRPC ?? [];
+    return rpcs.length > 0 ? (0, viem_1.fallback)(rpcs.map((url) => (0, viem_1.http)(url))) : (0, viem_1.http)();
+}
 /**
  * Get CEA address for a UEA on a specific chain
  *
@@ -58,7 +74,7 @@ async function getCEAAddress(ueaAddress, chain, rpcUrl) {
     const viemChain = getViemChain(chain);
     const client = (0, viem_1.createPublicClient)({
         chain: viemChain,
-        transport: (0, viem_1.http)(rpcUrl),
+        transport: ceaTransport(chain, rpcUrl),
     });
     if (cachedAddress) {
         // Address is cached — only re-check deployment status
@@ -91,7 +107,7 @@ async function getPushAccountForCEA(ceaAddress, chain, rpcUrl) {
     const viemChain = getViemChain(chain);
     const client = (0, viem_1.createPublicClient)({
         chain: viemChain,
-        transport: (0, viem_1.http)(rpcUrl),
+        transport: ceaTransport(chain, rpcUrl),
     });
     const uea = await client.readContract({
         abi: ceaFactory_evm_1.CEA_FACTORY_EVM,
@@ -118,7 +134,7 @@ async function isCEA(address, chain, rpcUrl) {
     const viemChain = getViemChain(chain);
     const client = (0, viem_1.createPublicClient)({
         chain: viemChain,
-        transport: (0, viem_1.http)(rpcUrl),
+        transport: ceaTransport(chain, rpcUrl),
     });
     return client.readContract({
         abi: ceaFactory_evm_1.CEA_FACTORY_EVM,

package/src/lib/orchestrator/internals/execute-funds-only.js

@@ -31,11 +31,19 @@ const response_builder_1 = require("./response-builder");
 const push_chain_tx_1 = require("./push-chain-tx");
 const svm_helpers_1 = require("./svm-helpers");
 const svm_1 = require("./pc20/svm");
+const gate_1 = require("./pc20/gate");
 const helpers_2 = require("./helpers");
 const response_builder_2 = require("./response-builder");
 const formatters_1 = require("../../formatters");
 async function executeFundsOnly(ctx, execute, eventBuffer, getResponseCallbacks) {
     const transformFn = (tx, buf = []) => (0, response_builder_2.transformToUniversalTxResponse)(ctx, tx, buf, getResponseCallbacks());
+    // Fail closed: a PC20 wrapper burn must never be broadcast from this path.
+    // It sends an empty payload, the gateway prepends the PC20 selector, and the
+    // chain's inbound decode hard-fails on the selector-only result with no
+    // revert — burning the wrapper and locking the canonical token forever.
+    // The orchestrator routes PC20 imports to the payload path; this is the
+    // backstop for any caller that reaches here anyway.
+    (0, gate_1.assertPC20ImportHasPayload)(execute, false, 'executeFundsOnly');
     const chain = ctx.universalSigner.account.chain;
     const { vm } = chain_1.CHAIN_INFO[chain];
     if (!helpers_1.SUPPORTED_GATEWAY_CHAINS.includes(chain)) {

package/src/lib/orchestrator/internals/pc20/errors.d.ts

@@ -75,7 +75,7 @@ export declare class PC20FactoryMismatchError extends PC20Error {
         registryFactory?: string;
     });
 }
-/** Token does not implement `pc20Metadata()`, or the metadata fails validation. */
+/** Token does not expose usable ERC-20 metadata, or the metadata fails validation. */
 export declare class InvalidPC20MetadataError extends PC20Error {
     constructor(message: string, ctx?: PC20ErrorContext);
 }

package/src/lib/orchestrator/internals/pc20/errors.js

@@ -108,7 +108,7 @@ class PC20FactoryMismatchError extends PC20Error {
     }
 }
 exports.PC20FactoryMismatchError = PC20FactoryMismatchError;
-/** Token does not implement `pc20Metadata()`, or the metadata fails validation. */
+/** Token does not expose usable ERC-20 metadata, or the metadata fails validation. */
 class InvalidPC20MetadataError extends PC20Error {
     constructor(message, ctx = {}) {
         super('PC20_INVALID_METADATA', message, ctx);

package/src/lib/orchestrator/internals/pc20/export.d.ts

@@ -61,6 +61,8 @@ export type PC20GasQuote = {
     protocolFee: bigint;
     gasPrice: bigint;
     chainNamespace: string;
+    /** Value encoded in the outbound request before UGPC applies its overhead. */
+    requestGasLimit: bigint;
     gasLimitUsed: bigint;
     isFirstExport: boolean;
     /**
@@ -84,10 +86,11 @@ export type PC20GasQuote = {
  *     `pc20DeploymentGasOverhead` and the transfer strands on the destination
  *     with the source token already locked.
  *
- * The second is unrecoverable without operator intervention, so the ceiling
- * always covers a deployment. `maxPCForGas` is a ceiling rather than a charge —
- * the unspent remainder is not consumed — so the only cost is a higher required
- * balance. `gasLimitUsed` itself is passed through unchanged.
+ * The second is unrecoverable without operator intervention, so the execution
+ * gas limit always covers a deployment. The buffered limit must be re-quoted
+ * and written into the outbound request; funding a higher ceiling while leaving
+ * the request at the default limit still makes the relayer submit an
+ * under-gassed destination transaction.
  */
 export declare function quotePC20Export(ctx: OrchestratorContext, pushPC20: `0x${string}`, destinationChain: CHAIN, gasLimit: bigint, opts: PC20ResolverOptions): Promise<PC20GasQuote>;
 /**
@@ -103,6 +106,7 @@ export declare function queryPC20OutboundGasFee(ctx: OrchestratorContext, pushPC
     gasFee: bigint;
     protocolFee: bigint;
     gasPrice: bigint;
+    requestGasLimit: bigint;
     gasLimitUsed: bigint;
     universalCoreAddress: `0x${string}`;
     isFirstExport: boolean;

package/src/lib/orchestrator/internals/pc20/export.js

@@ -47,6 +47,7 @@ exports.queryPC20OutboundGasFee = queryPC20OutboundGasFee;
 exports.resolveDestinationWrapper = resolveDestinationWrapper;
 exports.validatePC20Export = validatePC20Export;
 const viem_1 = require("viem");
+const enums_1 = require("../../../constants/enums");
 const abi_1 = require("../../../constants/abi");
 const chain_1 = require("../../../constants/chain");
 const context_1 = require("../context");
@@ -123,38 +124,55 @@ function assertMetadataFitsFactoryLimits(name, symbol) {
  *     `pc20DeploymentGasOverhead` and the transfer strands on the destination
  *     with the source token already locked.
  *
- * The second is unrecoverable without operator intervention, so the ceiling
- * always covers a deployment. `maxPCForGas` is a ceiling rather than a charge —
- * the unspent remainder is not consumed — so the only cost is a higher required
- * balance. `gasLimitUsed` itself is passed through unchanged.
+ * The second is unrecoverable without operator intervention, so the execution
+ * gas limit always covers a deployment. The buffered limit must be re-quoted
+ * and written into the outbound request; funding a higher ceiling while leaving
+ * the request at the default limit still makes the relayer submit an
+ * under-gassed destination transaction.
  */
 async function quotePC20Export(ctx, pushPC20, destinationChain, gasLimit, opts) {
     const namespace = (0, chain_namespace_1.chainToNamespace)(destinationChain);
     const core = await (0, resolver_1.getUniversalCoreAddress)(opts);
-    const result = await ctx.pushClient.readContract({
+    const readQuote = (limit) => ctx.pushClient.readContract({
         address: core,
         abi: abi_1.UNIVERSAL_CORE_EVM,
         functionName: 'getPC20ExportGasAndFees',
-        args: [namespace, gasLimit, pushPC20],
+        args: [namespace, limit, pushPC20],
     });
-    const [gasToken, gasFee, protocolFee, gasPrice, chainNamespace, gasLimitUsed, isFirstExport] = result;
-    const overhead = await ctx.pushClient.readContract({
-        address: core,
-        abi: abi_1.UNIVERSAL_CORE_EVM,
-        functionName: 'pc20DeploymentGasOverhead',
-        args: [namespace],
-    });
-    // Add the overhead even when the quote already included it. Double-counting
-    // raises a ceiling that is never fully spent; under-counting strands funds.
-    const gasLimitCeiling = gasLimitUsed + overhead;
-    (0, context_1.printLog)(ctx, `quotePC20Export — namespace=${chainNamespace}, gasLimitUsed=${gasLimitUsed}, ` +
-        `isFirstExport=${isFirstExport}, overhead=${overhead}, ceiling=${gasLimitCeiling}`);
+    const [baseQuote, overhead] = await Promise.all([
+        readQuote(gasLimit),
+        ctx.pushClient.readContract({
+            address: core,
+            abi: abi_1.UNIVERSAL_CORE_EVM,
+            functionName: 'pc20DeploymentGasOverhead',
+            args: [namespace],
+        }),
+    ]);
+    const baseGasLimitUsed = baseQuote[5];
+    const isFirstExport = baseQuote[6];
+    // Feed the resolved first quote back as the explicit request limit. UGPC
+    // applies its deployment overhead to that value, giving one additional
+    // safety margin while keeping the fee quote and final destination limit in
+    // sync. Passing `gasLimitCeiling` here would make UGPC add the overhead yet
+    // again and over-provision the relayer transaction.
+    const gasLimitCeiling = baseGasLimitUsed + overhead;
+    const isEvmDestination = (0, chain_namespace_1.vmForChain)(destinationChain) === enums_1.VM.EVM;
+    const requestGasLimit = isEvmDestination ? baseGasLimitUsed : gasLimit;
+    // Solana has a separate rent/compute-budget requote path; preserve its base
+    // quote here so this EVM wrapper-deployment guard does not double-count it.
+    const bufferedQuote = isEvmDestination
+        ? await readQuote(requestGasLimit)
+        : baseQuote;
+    const [gasToken, gasFee, protocolFee, gasPrice, chainNamespace, gasLimitUsed] = bufferedQuote;
+    (0, context_1.printLog)(ctx, `quotePC20Export — namespace=${chainNamespace}, baseGasLimit=${baseGasLimitUsed}, ` +
+        `isFirstExport=${isFirstExport}, overhead=${overhead}, executionGasLimit=${gasLimitUsed}`);
     return {
         gasToken,
         gasFee,
         protocolFee,
         gasPrice,
         chainNamespace,
+        requestGasLimit,
         gasLimitUsed,
         isFirstExport,
         gasLimitCeiling,
@@ -180,6 +198,7 @@ async function queryPC20OutboundGasFee(ctx, pushPC20, gasLimit, destinationChain
         gasFee: quote.gasFee,
         protocolFee: quote.protocolFee,
         gasPrice: quote.gasPrice,
+        requestGasLimit: quote.requestGasLimit,
         gasLimitUsed: quote.gasLimitUsed,
         universalCoreAddress,
         isFirstExport: quote.isFirstExport,

package/src/lib/orchestrator/internals/pc20/resolver.d.ts

@@ -36,12 +36,11 @@
  */
 import { type Hex } from 'viem';
 import { CHAIN, PUSH_NETWORK, VM } from '../../../constants/enums';
-/** Metadata read off a Push-native PC20 via `pc20Metadata()`. */
+/** Standard ERC-20 metadata forwarded when exporting a Push-native PC20. */
 export type PC20Metadata = {
     name: string;
     symbol: string;
     decimals: number;
-    originAddress: `0x${string}`;
 };
 /** A confirmed wrapper deployment on one external chain. */
 export type PC20DeploymentInfo = {
@@ -122,12 +121,11 @@ export declare function resolveWrapperToSource(chain: CHAIN, address: string, op
  */
 export declare function verifyEvmWrapperIdentity(chain: CHAIN, address: string, pushAddress: `0x${string}`, opts: PC20ResolverOptions): Promise<void>;
 /**
- * Read and validate `pc20Metadata()` on a Push-native token.
+ * Read and validate standard ERC-20 metadata on a Push-native token.
  *
- * The absence of `pc20Metadata` is the discriminator between a PC20 and any
- * other ERC20 — never the symbol. A synthetic PRC20 is detected separately so
- * it gets an error that points at the right API rather than reading as
- * "your token is broken".
+ * Every metadata-compatible ERC-20 born on Push Chain is eligible for PC20
+ * export. Synthetic PRC20s expose `CHAIN_NAMESPACE()` and are rejected even
+ * though they also implement the standard metadata functions.
  */
 export declare function readPushPC20Metadata(pushAddress: `0x${string}`, opts: PC20ResolverOptions): Promise<PC20Metadata>;
 /**

package/src/lib/orchestrator/internals/pc20/resolver.js

@@ -111,10 +111,9 @@ function clientFor(chain, opts) {
  * dispatches them synchronously, which is what puts them in the same batch
  * window — awaiting them one at a time would silently become N round trips.
  *
- * Failures are captured per call rather than thrown, because several PC20 probes
- * are *expected* to revert: `pc20Metadata()` reverting on a plain ERC20 is the
- * primary discriminator, not an error condition. Callers interpret each result
- * individually via {@link unwrap}.
+ * Failures are captured per call rather than thrown, because optional identity
+ * probes such as `CHAIN_NAMESPACE()` are expected to revert on ordinary ERC-20s.
+ * Callers interpret each result individually via {@link unwrap}.
  */
 async function batchRead(client, contracts) {
     exports.__readCount.n += 1;
@@ -376,12 +375,11 @@ async function verifyEvmWrapperIdentity(chain, address, pushAddress, opts) {
 // Push-native metadata
 // ---------------------------------------------------------------------------
 /**
- * Read and validate `pc20Metadata()` on a Push-native token.
+ * Read and validate standard ERC-20 metadata on a Push-native token.
  *
- * The absence of `pc20Metadata` is the discriminator between a PC20 and any
- * other ERC20 — never the symbol. A synthetic PRC20 is detected separately so
- * it gets an error that points at the right API rather than reading as
- * "your token is broken".
+ * Every metadata-compatible ERC-20 born on Push Chain is eligible for PC20
+ * export. Synthetic PRC20s expose `CHAIN_NAMESPACE()` and are rejected even
+ * though they also implement the standard metadata functions.
  */
 async function readPushPC20Metadata(pushAddress, opts) {
     const pushChain = (0, helpers_1.getPushChainForNetwork)(opts.network);
@@ -390,10 +388,26 @@ async function readPushPC20Metadata(pushAddress, opts) {
     if (cached)
         return cached;
     const client = clientFor(pushChain, opts);
-    const [metaEntry, codeEntry] = await Promise.all([
+    const [metadataEntries, codeEntry] = await Promise.all([
         batchRead(client, [
-            { address: pushAddress, abi: abi_1.IPC20_EVM, functionName: 'pc20Metadata', args: [] },
-        ]).then((r) => r[0]),
+            { address: pushAddress, abi: abi_1.ERC20_EVM, functionName: 'name', args: [] },
+            { address: pushAddress, abi: abi_1.ERC20_EVM, functionName: 'symbol', args: [] },
+            { address: pushAddress, abi: abi_1.ERC20_EVM, functionName: 'decimals', args: [] },
+            {
+                address: pushAddress,
+                abi: [
+                    {
+                        type: 'function',
+                        name: 'CHAIN_NAMESPACE',
+                        inputs: [],
+                        outputs: [{ name: '', type: 'string' }],
+                        stateMutability: 'view',
+                    },
+                ],
+                functionName: 'CHAIN_NAMESPACE',
+                args: [],
+            },
+        ]),
         (async () => {
             exports.__readCount.n += 1;
             return { status: 'success', result: await client.getCode({ address: pushAddress }) };
@@ -406,22 +420,19 @@ async function readPushPC20Metadata(pushAddress, opts) {
             address: pushAddress,
         });
     }
-    const meta = unwrap(metaEntry);
-    if (!meta) {
-        if (await isSyntheticPRC20(pushAddress, opts)) {
-            throw new errors_1.PC20ExpectedButPRC20Error({
-                chain: String(pushChain),
-                address: pushAddress,
-            });
-        }
-        throw new errors_1.InvalidPC20MetadataError('Token does not implement pc20Metadata() and is not a Push-native PC20.', { chain: String(pushChain), address: pushAddress });
+    const prc20Namespace = unwrap(metadataEntries[3]);
+    if (typeof prc20Namespace === 'string') {
+        throw new errors_1.PC20ExpectedButPRC20Error({
+            chain: String(pushChain),
+            address: pushAddress,
+            chainNamespace: prc20Namespace,
+        });
     }
-    const [name, symbol, decimals, originAddress] = meta;
-    // The origin binding is what makes the metadata trustworthy: a contract can
-    // return any name it likes, but claiming to originate at a different address
-    // means it is not the canonical source for this token.
-    if ((0, viem_1.getAddress)(originAddress) !== (0, viem_1.getAddress)(pushAddress)) {
-        throw new errors_1.InvalidPC20MetadataError(`pc20Metadata().originAddress (${originAddress}) does not match the token address.`, { chain: String(pushChain), address: pushAddress });
+    const name = unwrap(metadataEntries[0]);
+    const symbol = unwrap(metadataEntries[1]);
+    const decimals = unwrap(metadataEntries[2]);
+    if (name === undefined || symbol === undefined || decimals === undefined) {
+        throw new errors_1.InvalidPC20MetadataError('Token must implement the ERC-20 metadata functions name(), symbol(), and decimals().', { chain: String(pushChain), address: pushAddress });
     }
     if (!name || !symbol) {
         throw new errors_1.InvalidPC20MetadataError('PC20 name and symbol must be non-empty.', {
@@ -429,41 +440,21 @@ async function readPushPC20Metadata(pushAddress, opts) {
             address: pushAddress,
         });
     }
+    const normalizedDecimals = Number(decimals);
+    if (!Number.isInteger(normalizedDecimals) || normalizedDecimals < 0 || normalizedDecimals > 255) {
+        throw new errors_1.InvalidPC20MetadataError('PC20 decimals must be a valid uint8 value.', {
+            chain: String(pushChain),
+            address: pushAddress,
+        });
+    }
     const validated = {
         name,
         symbol,
-        decimals: Number(decimals),
-        originAddress: (0, viem_1.getAddress)(originAddress),
+        decimals: normalizedDecimals,
     };
     metadataCache.set(key, validated);
     return validated;
 }
-/**
- * Distinguish a synthetic PRC20 from an arbitrary ERC20.
- *
- * PRC20s expose the origin chain they wrap; PC20s do not. Checked only after
- * `pc20Metadata()` has already failed, so it costs nothing on the happy path.
- */
-async function isSyntheticPRC20(address, opts) {
-    const client = clientFor((0, helpers_1.getPushChainForNetwork)(opts.network), opts);
-    const [entry] = await batchRead(client, [
-        {
-            address,
-            abi: [
-                {
-                    type: 'function',
-                    name: 'CHAIN_NAMESPACE',
-                    inputs: [],
-                    outputs: [{ name: '', type: 'string' }],
-                    stateMutability: 'view',
-                },
-            ],
-            functionName: 'CHAIN_NAMESPACE',
-            args: [],
-        },
-    ]);
-    return typeof unwrap(entry) === 'string';
-}
 // ---------------------------------------------------------------------------
 // Destination-side lookups
 // ---------------------------------------------------------------------------

package/src/lib/orchestrator/internals/route-handlers.js

@@ -487,6 +487,7 @@ async function executeUoaToCea(ctx, params, executeFn) {
         (0, context_1.printLog)(ctx, `executeUoaToCea — PAYLOAD-only: using native PRC-20 ${prc20Token} for chain ${targetChain} with zero burn amount`);
     }
     const gasLimitForQuery = params.gasLimit ?? BigInt(0);
+    let outboundGasLimit = gasLimitForQuery;
     // --- 202: Gas estimation (spec-ordered before 203) ---
     let gasFee = BigInt(0);
     let protocolFee = BigInt(0);
@@ -499,9 +500,20 @@ async function executeUoaToCea(ctx, params, executeFn) {
             // getPC20ExportGasAndFees accounts for the first-export deployment
             // overhead, and quoting the wrong one strands the destination transfer.
             const pc20Export = params._pc20;
-            const result = pc20Export?.direction === 'export'
-                ? await (0, export_1.queryPC20OutboundGasFee)(ctx, prc20Token, gasLimitForQuery, targetChain)
-                : await (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimitForQuery, targetChain);
+            const isPc20ExportQuote = pc20Export?.direction === 'export';
+            let result;
+            if (isPc20ExportQuote) {
+                const pc20Quote = await (0, export_1.queryPC20OutboundGasFee)(ctx, prc20Token, gasLimitForQuery, targetChain);
+                result = pc20Quote;
+                // PC20 first exports deploy a wrapper on the destination. The quote is
+                // re-issued with that deployment margin, and the relayer must receive
+                // the corresponding explicit request limit—not the caller's original
+                // zero/default.
+                outboundGasLimit = pc20Quote.requestGasLimit;
+            }
+            else {
+                result = await (0, gas_calculator_1.queryOutboundGasFee)(ctx, prc20Token, gasLimitForQuery, targetChain);
+            }
             gasFee = result.gasFee;
             protocolFee = result.protocolFee;
             gasToken = result.gasToken;
@@ -567,7 +579,7 @@ async function executeUoaToCea(ctx, params, executeFn) {
             destinationUserData: ceaPayload,
         })
         : ceaPayload;
-    const outboundReq = (0, payload_builders_2.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, gasLimitForQuery, outboundPayload, ueaAddress, // revert recipient is the UEA
+    const outboundReq = (0, payload_builders_2.buildOutboundRequest)(targetBytes, prc20Token, burnAmount, outboundGasLimit, outboundPayload, ueaAddress, // revert recipient is the UEA
     params.maxPCForGas ?? BigInt(0));
     (0, context_1.printLog)(ctx, `executeUoaToCea — outbound request: ${JSON.stringify({
         recipient: outboundReq.recipient,

package/src/lib/orchestrator/orchestrator.js

@@ -266,8 +266,8 @@ class Orchestrator {
                     // Single PC20 gate. Downstream builders only ever see the legacy
                     // PRC20/native shape; the PC20 branch is added here in Phase 2.
                     const legacy = await (0, gate_1.gateFunds)(this.ctx, execute);
-                    // SVM PC20 imports never take the raw funds-only path: the Solana
-                    // gateway prepends the PC20 selector to the (empty) payload and
+                    // PC20 imports never take the raw funds-only path, on EITHER VM.
+                    // The gateway prepends the PC20 selector to the (empty) payload and
                     // classifies the RESULT as FUNDS_AND_PAYLOAD, and the chain's
                     // inbound decode hard-fails on that selector-only payload with no
                     // revert — the wrapper is already burned (same "0x" vs "" guard as
@@ -275,9 +275,18 @@ class Orchestrator {
                     // payload (UEA multicall transfer to `to`), which classifies and
                     // decodes legitimately — the same always-forward mitigation R3
                     // ships on both VMs.
-                    const svmPc20Import = legacy._pc20?.direction === 'import' &&
-                        chain_1.CHAIN_INFO[this.ctx.universalSigner.account.chain].vm === enums_1.VM.SVM;
-                    return attachPerCallHookForWait(!hasData && !svmPc20Import
+                    //
+                    // This was previously gated on VM.SVM, which left EVM wrapper burns
+                    // on the unsafe path: observed on Donut as a burned wrapper whose
+                    // canonical token was never unlocked. The brick is at ballot
+                    // finalization — NormalizeForTxType (x/uexecutor/types/inbound.go)
+                    // strips the selector, gets '0x', which passes its `!= ""` empty
+                    // check, and DecodeRawPayload('0x') then fails — so no handler runs
+                    // at all: no deploy, no credit, and no INBOUND_REVERT. With a real
+                    // forward payload the decode succeeds and the funds_and_payload
+                    // handler deploys the UEA and credits normally.
+                    const pc20Import = legacy._pc20?.direction === 'import';
+                    return attachPerCallHookForWait(!hasData && !pc20Import
                         ? await (0, internals_1.executeFundsOnly)(this.ctx, legacy, eventBuffer, rcb)
                         : await (0, internals_1.executeFundsWithPayload)(this.ctx, legacy, eventBuffer, rcb));
                 }