@ton/ton 15.4.0 → 16.1.0

package/dist/config/ConfigParser.js

@@ -5,7 +5,12 @@ exports.parseValidatorSet = parseValidatorSet;
 exports.parseBridge = parseBridge;
 exports.configParseMasterAddressRequired = configParseMasterAddressRequired;
 exports.configParse5 = configParse5;
+exports.configParse6 = configParse6;
+exports.configParse7 = configParse7;
+exports.configParse9 = configParse9;
+exports.configParse10 = configParse10;
 exports.configParse13 = configParse13;
+exports.configParse14 = configParse14;
 exports.configParse15 = configParse15;
 exports.configParse16 = configParse16;
 exports.configParse17 = configParse17;
@@ -16,15 +21,21 @@ exports.configParseWorkchainDescriptor = configParseWorkchainDescriptor;
 exports.configParse12 = configParse12;
 exports.configParseValidatorSet = configParseValidatorSet;
 exports.configParseBridge = configParseBridge;
+exports.loadJettonBridgeParams = loadJettonBridgeParams;
 exports.configParseGasLimitsPrices = configParseGasLimitsPrices;
+exports.configParseBlockLimits = configParseBlockLimits;
 exports.configParseMsgPrices = configParseMsgPrices;
 exports.configParse28 = configParse28;
 exports.configParse29 = configParse29;
+exports.configParse31 = configParse31;
+exports.configParse44 = configParse44;
+exports.configParse45 = configParse45;
 exports.parseProposalSetup = parseProposalSetup;
 exports.parseVotingSetup = parseVotingSetup;
 exports.loadConfigParamById = loadConfigParamById;
 exports.loadConfigParamsAsSlice = loadConfigParamsAsSlice;
 exports.parseFullConfig = parseFullConfig;
+exports.parseFullerConfig = parseFullerConfig;
 const core_1 = require("@ton/core");
 function configParseMasterAddress(slice) {
     if (slice) {
@@ -37,7 +48,7 @@ function configParseMasterAddress(slice) {
 function readPublicKey(slice) {
     // 8e81278a
     if (slice.loadUint(32) !== 0x8e81278a) {
-        throw Error('Invalid config');
+        throw Error('Invalid publicKey');
     }
     return slice.loadBuffer(32);
 }
@@ -62,7 +73,7 @@ const ValidatorDescriptionDictValue = {
             };
         }
         else {
-            throw Error('Invalid config');
+            throw Error('Invalid validator description dict');
         }
     }
 };
@@ -99,6 +110,7 @@ function parseValidatorSet(slice) {
             list
         };
     }
+    return null;
 }
 function parseBridge(slice) {
     const bridgeAddress = new core_1.Address(-1, slice.loadBuffer(32));
@@ -118,13 +130,13 @@ function parseBridge(slice) {
 }
 function configParseMasterAddressRequired(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('Invalid master address');
     }
     return configParseMasterAddress(slice);
 }
 function configParse5(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config5 slice');
     }
     const magic = slice.loadUint(8);
     if (magic === 0x01) {
@@ -137,28 +149,82 @@ function configParse5(slice) {
             feeBurnDenominator
         };
     }
-    throw new Error('Invalid config');
+    throw new Error('Invalid config5');
+}
+// _ mint_new_price:Grams mint_add_price:Grams = ConfigParam 6;
+function configParse6(slice) {
+    if (!slice) {
+        // no param in mainnet for now, so throwing will cause crash of parseFullConfig()
+        return null;
+    }
+    const mintNewPrice = slice.loadCoins();
+    const mintAddPrice = slice.loadCoins();
+    return {
+        mintNewPrice,
+        mintAddPrice
+    };
+}
+// extra_currencies$_ dict:(HashmapE 32 (VarUInteger 32)) = ExtraCurrencyCollection;
+// _ to_mint:ExtraCurrencyCollection = ConfigParam 7;
+function configParse7(slice) {
+    if (!slice) {
+        throw Error('No config7 slice');
+    }
+    return {
+        toMint: (0, core_1.loadExtraCurrency)(slice.loadRef()),
+    };
+}
+// _ mandatory_params:(Hashmap 32 True) = ConfigParam 9;
+function configParse9(slice) {
+    if (!slice) {
+        throw Error('No config9 slice');
+    }
+    return new Set(slice.loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Uint(0)).keys());
+}
+// _ critical_params:(Hashmap 32 True) = ConfigParam 10;
+function configParse10(slice) {
+    if (!slice) {
+        throw Error('No config10 slice');
+    }
+    return new Set(slice.loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Uint(0)).keys());
 }
 function configParse13(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config13 slice');
     }
     const magic = slice.loadUint(8);
-    if (magic === 0x1a) {
-        const deposit = slice.loadCoins();
-        const bitPrice = slice.loadCoins();
-        const cellPrice = slice.loadCoins();
-        return {
-            deposit,
-            bitPrice,
-            cellPrice
-        };
+    if (magic !== 0x1a) {
+        throw new Error('Invalid config13');
+    }
+    const deposit = slice.loadCoins();
+    const bitPrice = slice.loadCoins();
+    const cellPrice = slice.loadCoins();
+    return {
+        deposit,
+        bitPrice,
+        cellPrice
+    };
+}
+// block_grams_created#6b masterchain_block_fee:Grams basechain_block_fee:Grams = BlockCreateFees;
+// _ BlockCreateFees = ConfigParam 14;
+function configParse14(slice) {
+    if (!slice) {
+        throw Error('No config14 slice');
+    }
+    const magic = slice.loadUint(8);
+    if (magic !== 0x6b) {
+        throw new Error('Invalid config14');
     }
-    throw new Error('Invalid config');
+    const masterchainBlockFee = slice.loadCoins();
+    const workchainBlockFee = slice.loadCoins();
+    return {
+        masterchainBlockFee,
+        workchainBlockFee
+    };
 }
 function configParse15(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config15 slice');
     }
     const validatorsElectedFor = slice.loadUint(32);
     const electorsStartBefore = slice.loadUint(32);
@@ -173,7 +239,7 @@ function configParse15(slice) {
 }
 function configParse16(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config16 slice');
     }
     const maxValidators = slice.loadUint(16);
     const maxMainValidators = slice.loadUint(16);
@@ -186,7 +252,7 @@ function configParse16(slice) {
 }
 function configParse17(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config17 slice');
     }
     const minStake = slice.loadCoins();
     const maxStake = slice.loadCoins();
@@ -206,7 +272,7 @@ const StoragePricesDictValue = {
     parse(src) {
         const header = src.loadUint(8);
         if (header !== 0xcc) {
-            throw Error('Invalid config');
+            throw Error('Invalid storage prices dict');
         }
         const utime_since = src.loadUint(32);
         const bit_price_ps = src.loadUintBig(64);
@@ -224,7 +290,7 @@ const StoragePricesDictValue = {
 };
 function configParse18(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config18 slice');
     }
     return slice.loadDictDirect(core_1.Dictionary.Keys.Buffer(4), StoragePricesDictValue).values();
 }
@@ -248,7 +314,7 @@ function configParse40(slice) {
     }
     const header = slice.loadUint(8);
     if (header !== 1) {
-        throw Error('Invalid config');
+        throw Error('Invalid config40');
     }
     const defaultFlatFine = slice.loadCoins();
     const defaultProportionaFine = slice.loadCoins();
@@ -278,7 +344,7 @@ function configParse40(slice) {
 function configParseWorkchainDescriptor(slice) {
     const constructorTag = slice.loadUint(8);
     if (!(constructorTag == 0xA6 || constructorTag == 0xA7)) {
-        throw Error('Invalid config');
+        throw Error('Invalid workchain descriptor');
     }
     const enabledSince = slice.loadUint(32);
     const actialMinSplit = slice.loadUint(8);
@@ -293,7 +359,7 @@ function configParseWorkchainDescriptor(slice) {
     const version = slice.loadUint(32);
     // Only basic format supported
     if (!slice.loadUint(4)) {
-        throw Error('Invalid config');
+        throw Error('Not basic workchain descriptor');
     }
     const vmVersion = slice.loadInt(32);
     const vmMode = slice.loadUintBig(64);
@@ -349,7 +415,7 @@ const WorkchainDescriptorDictValue = {
 };
 function configParse12(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No config12 slice');
     }
     const wd = slice.loadDict(core_1.Dictionary.Keys.Uint(32), WorkchainDescriptorDictValue);
     if (wd) {
@@ -369,6 +435,68 @@ function configParseBridge(slice) {
     }
     return parseBridge(slice);
 }
+function loadJettonBridgeParams(slice) {
+    if (!slice) {
+        return null;
+    }
+    const magic = slice.loadUint(8);
+    // jetton_bridge_params_v0#00 bridge_address:bits256 oracles_address:bits256 oracles:(HashmapE 256 uint256)
+    // state_flags:uint8 burn_bridge_fee:Coins = JettonBridgeParams;
+    if (magic === 0x00) {
+        const bridgeAddress = new core_1.Address(-1, slice.loadBuffer(32));
+        const oracleAddress = new core_1.Address(-1, slice.loadBuffer(32));
+        const oraclesRaw = slice.loadDict(core_1.Dictionary.Keys.Buffer(32), core_1.Dictionary.Values.Buffer(32));
+        const oracles = [...oraclesRaw].map(e => ({
+            addr: new core_1.Address(-1, e[0]),
+            pubkey: e[1],
+        }));
+        const flags = slice.loadUint(8);
+        const bridgeBurnFee = slice.loadCoins();
+        return {
+            bridgeAddress,
+            oracleAddress,
+            oracles,
+            flags,
+            bridgeBurnFee
+        };
+    }
+    // jetton_bridge_params_v1#01 bridge_address:bits256 oracles_address:bits256 oracles:(HashmapE 256 uint256)
+    // state_flags:uint8 prices:^JettonBridgePrices external_chain_address:bits256 = JettonBridgeParams;
+    if (magic === 0x01) {
+        const bridgeAddress = new core_1.Address(-1, slice.loadBuffer(32));
+        const oracleAddress = new core_1.Address(-1, slice.loadBuffer(32));
+        const oraclesRaw = slice.loadDict(core_1.Dictionary.Keys.Buffer(32), core_1.Dictionary.Values.Buffer(32));
+        const oracles = [...oraclesRaw].map(e => ({
+            addr: new core_1.Address(-1, e[0]),
+            pubkey: e[1],
+        }));
+        const flags = slice.loadUint(8);
+        const pricesRef = slice.loadRef().beginParse();
+        const bridgeBurnFee = pricesRef.loadCoins();
+        const bridgeMintFee = pricesRef.loadCoins();
+        const walletMinTonsForStorage = pricesRef.loadCoins();
+        const walletGasConsumption = pricesRef.loadCoins();
+        const minterMinTonsForStorage = pricesRef.loadCoins();
+        const discoverGasConsumption = pricesRef.loadCoins();
+        const externalChainAddress = slice.loadBuffer(32);
+        return {
+            bridgeAddress,
+            oracleAddress,
+            oracles,
+            flags,
+            jettonBridgePrices: {
+                bridgeBurnFee,
+                bridgeMintFee,
+                walletMinTonsForStorage,
+                walletGasConsumption,
+                minterMinTonsForStorage,
+                discoverGasConsumption
+            },
+            externalChainAddress
+        };
+    }
+    throw new Error('Invalid msg prices param');
+}
 function parseGasLimitsInternal(slice) {
     const tag = slice.loadUint(8);
     if (tag === 0xde) {
@@ -406,12 +534,12 @@ function parseGasLimitsInternal(slice) {
         };
     }
     else {
-        throw Error('Invalid config');
+        throw Error('Invalid gas limits internal');
     }
 }
 function configParseGasLimitsPrices(slice) {
     if (!slice) {
-        throw Error('Invalid config');
+        throw Error('No gas limits slice');
     }
     const tag = slice.loadUint(8);
     if (tag === 0xd1) {
@@ -425,12 +553,74 @@ function configParseGasLimitsPrices(slice) {
         };
     }
     else {
-        throw Error('Invalid config');
+        throw Error('Invalid gas limits');
+    }
+}
+// param_limits#c3 underload:# soft_limit:# { underload <= soft_limit }
+// hard_limit:# { soft_limit <= hard_limit } = ParamLimits;
+function configParseLimitParams(slice) {
+    const paramsLimitTag = slice.loadUint(8);
+    if (paramsLimitTag !== 0xc3) {
+        throw Error('Invalid params limit slice');
+    }
+    const underload = slice.loadUint(32);
+    const softLimit = slice.loadUint(32);
+    const hardLimit = slice.loadUint(32);
+    if ((underload > softLimit) || (softLimit > hardLimit)) {
+        throw Error('Incosistent limitParams');
+    }
+    return {
+        underload,
+        softLimit,
+        hardLimit
+    };
+}
+function configParseBlockLimits(slice) {
+    if (!slice) {
+        throw Error('No block limits slice');
+    }
+    const blockLimitTag = slice.loadUint(8);
+    // block_limits#5d bytes:ParamLimits gas:ParamLimits lt_delta:ParamLimits = BlockLimits;
+    if (blockLimitTag === 0x5d) {
+        const bytes = configParseLimitParams(slice);
+        const gas = configParseLimitParams(slice);
+        const ltDelta = configParseLimitParams(slice);
+        return {
+            bytes,
+            gas,
+            ltDelta
+        };
     }
+    // imported_msg_queue_limits#d3 max_bytes:# max_msgs:# = ImportedMsgQueueLimits;
+    // block_limits_v2#5e bytes:ParamLimits gas:ParamLimits lt_delta:ParamLimits
+    // collated_data:ParamLimits imported_msg_queue:ImportedMsgQueueLimits = BlockLimits;
+    if (blockLimitTag === 0x5e) {
+        const bytes = configParseLimitParams(slice);
+        const gas = configParseLimitParams(slice);
+        const ltDelta = configParseLimitParams(slice);
+        const collatedData = configParseLimitParams(slice);
+        const importedMsgQueueTag = slice.loadUint(8);
+        if (importedMsgQueueTag !== 0xd3) {
+            throw Error('Invalid importedMsgQueue');
+        }
+        const maxBytes = slice.loadUint(32);
+        const maxMsgs = slice.loadUint(32);
+        return {
+            bytes,
+            gas,
+            ltDelta,
+            collatedData,
+            importedMsgQueue: {
+                maxBytes,
+                maxMsgs
+            }
+        };
+    }
+    throw Error('Invalid block limits');
 }
 function configParseMsgPrices(slice) {
     if (!slice) {
-        throw new Error('Invalid config');
+        throw new Error('No msg prices slice');
     }
     const magic = slice.loadUint(8);
     if (magic !== 0xea) {
@@ -445,14 +635,9 @@ function configParseMsgPrices(slice) {
         nextFrac: slice.loadUint(16)
     };
 }
-// catchain_config#c1 mc_catchain_lifetime:uint32 shard_catchain_lifetime:uint32 
-//   shard_validators_lifetime:uint32 shard_validators_num:uint32 = CatchainConfig;
-// catchain_config_new#c2 flags:(## 7) { flags = 0 } shuffle_mc_validators:Bool
-//   mc_catchain_lifetime:uint32 shard_catchain_lifetime:uint32
-//   shard_validators_lifetime:uint32 shard_validators_num:uint32 = CatchainConfig;
 function configParse28(slice) {
     if (!slice) {
-        throw new Error('Invalid config');
+        throw new Error('No config28 slice');
     }
     const magic = slice.loadUint(8);
     if (magic === 0xc1) {
@@ -483,7 +668,7 @@ function configParse28(slice) {
             shardValidatorsCount
         };
     }
-    throw new Error('Invalid config');
+    throw new Error('Invalid config28');
 }
 // consensus_config#d6 round_candidates:# { round_candidates >= 1 }
 //   next_candidate_delay_ms:uint32 consensus_timeout_ms:uint32
@@ -502,7 +687,7 @@ function configParse28(slice) {
 //   proto_version:uint16 = ConsensusConfig;
 function configParse29(slice) {
     if (!slice) {
-        throw new Error('Invalid config');
+        throw new Error('No config29 slice');
     }
     const magic = slice.loadUint(8);
     if (magic === 0xd6) {
@@ -603,13 +788,69 @@ function configParse29(slice) {
             catchainMaxBlocksCoeff
         };
     }
-    throw new Error('Invalid config');
+    throw new Error('Invalid config29');
+}
+// _ fundamental_smc_addr:(HashmapE 256 True) = ConfigParam 31;
+function configParse31(slice) {
+    if (!slice) {
+        throw Error('No config31 slice');
+    }
+    const rawAddrsDict = slice.loadDict(core_1.Dictionary.Keys.Buffer(32), core_1.Dictionary.Values.Uint(0));
+    // only masterchain addrs here - https://docs.ton.org/v3/documentation/network/config-params/overview#param-31
+    return [...rawAddrsDict].map(e => new core_1.Address(-1, e[0]));
+}
+// suspended_address_list#00 addresses:(HashmapE 288 Unit) suspended_until:uint32 = SuspendedAddressList;
+// _ SuspendedAddressList = ConfigParam 44;
+function configParse44(slice) {
+    if (!slice) {
+        throw Error('No config44 slice');
+    }
+    const magic = slice.loadUint(8);
+    if (magic !== 0x00) {
+        throw new Error('Invalid config44');
+    }
+    // buffer36 = uint288
+    const rawAddrsDict = slice.loadDict(core_1.Dictionary.Keys.Buffer(36), core_1.Dictionary.Values.Uint(0));
+    const suspendedUntil = slice.loadUint(32);
+    // uint288 = [wc:int32 addr:uint256]
+    const constructedAddrs = [...rawAddrsDict].map(e => new core_1.Address(e[0].readInt32BE(), e[0].subarray(4)));
+    return {
+        addresses: constructedAddrs,
+        suspendedUntil
+    };
+}
+const PrecompiledContractsDictValue = {
+    serialize: () => { throw Error('not implemented'); },
+    parse: (src) => {
+        const tag = src.loadUint(8);
+        if (tag !== 0xb0) {
+            throw new Error('Invalid precompiled contracts dict');
+        }
+        return src.loadUintBig(64);
+    },
+};
+// precompiled_smc#b0 gas_usage:uint64 = PrecompiledSmc; 
+// precompiled_contracts_config#c0 list:(HashmapE 256 PrecompiledSmc) = PrecompiledContractsConfig;
+// _ PrecompiledContractsConfig = ConfigParam 45;
+function configParse45(slice) {
+    if (!slice) {
+        throw Error('No config45 slice');
+    }
+    const magic = slice.loadUint(8);
+    if (magic !== 0xc0) {
+        throw new Error('Invalid config45');
+    }
+    const precompiledContracts = slice.loadDict(core_1.Dictionary.Keys.Buffer(32), PrecompiledContractsDictValue);
+    return [...precompiledContracts].map((e) => ({
+        hash: e[0],
+        gasUsed: e[1]
+    }));
 }
 // cfg_vote_cfg#36 min_tot_rounds:uint8 max_tot_rounds:uint8 min_wins:uint8 max_losses:uint8 min_store_sec:uint32 max_store_sec:uint32 bit_price:uint32 cell_price:uint32 = ConfigProposalSetup;
 function parseProposalSetup(slice) {
     const magic = slice.loadUint(8);
     if (magic !== 0x36) {
-        throw new Error('Invalid config');
+        throw new Error('Invalid proposal setup');
     }
     const minTotalRounds = slice.loadUint(8);
     const maxTotalRounds = slice.loadUint(8);
@@ -624,11 +865,11 @@ function parseProposalSetup(slice) {
 // cfg_vote_setup#91 normal_params:^ConfigProposalSetup critical_params:^ConfigProposalSetup = ConfigVotingSetup;
 function parseVotingSetup(slice) {
     if (!slice) {
-        throw new Error('Invalid config');
+        throw new Error('No voting setup');
     }
     const magic = slice.loadUint(8);
     if (magic !== 0x91) {
-        throw new Error('Invalid config');
+        throw new Error('Invalid voting setup');
     }
     const normalParams = parseProposalSetup(slice.loadRef().beginParse());
     const criticalParams = parseProposalSetup(slice.loadRef().beginParse());
@@ -690,10 +931,66 @@ function parseFullConfig(configs) {
         },
         catchain: configParse28(configs.get(28)),
         consensus: configParse29(configs.get(29))
-        // TODO: mint_new_price:Grams mint_add_price:Grams = ConfigParam 6;
-        // TODO: to_mint:ExtraCurrencyCollection = ConfigParam 7
-        // TODO: mandatory_params:(Hashmap 32 True) = ConfigParam 9
-        // TODO: critical_params:(Hashmap 32 True) = ConfigParam 10
-        // TODO: BlockCreateFees = ConfigParam 14
+    };
+}
+function parseFullerConfig(configs) {
+    return {
+        configAddress: configParseMasterAddressRequired(configs.get(0)),
+        electorAddress: configParseMasterAddressRequired(configs.get(1)),
+        minterAddress: configParseMasterAddress(configs.get(2)),
+        feeCollectorAddress: configParseMasterAddress(configs.get(3)),
+        dnsRootAddress: configParseMasterAddress(configs.get(4)),
+        burningConfig: configParse5(configs.get(5)),
+        extraCurrenciesMintPrices: configParse6(configs.get(6)),
+        extraCurrencies: configParse7(configs.get(7)),
+        globalVersion: configParse8(configs.get(8)),
+        configMandatoryParams: configParse9(configs.get(9)),
+        configCriticalParams: configParse10(configs.get(10)),
+        voting: parseVotingSetup(configs.get(11)),
+        workchains: configParse12(configs.get(12)),
+        complaintCost: configParse13(configs.get(13)),
+        blockCreationRewards: configParse14(configs.get(14)),
+        validators: {
+            ...configParse15(configs.get(15)),
+            ...configParse16(configs.get(16)),
+            ...configParse17(configs.get(17))
+        },
+        storagePrices: configParse18(configs.get(18)),
+        gasPrices: {
+            masterchain: configParseGasLimitsPrices(configs.get(20)),
+            workchain: configParseGasLimitsPrices(configs.get(21)),
+        },
+        blockLimits: {
+            masterchain: configParseBlockLimits(configs.get(22)),
+            workchain: configParseBlockLimits(configs.get(23)),
+        },
+        msgPrices: {
+            masterchain: configParseMsgPrices(configs.get(24)),
+            workchain: configParseMsgPrices(configs.get(25)),
+        },
+        catchain: configParse28(configs.get(28)),
+        consensus: configParse29(configs.get(29)),
+        fundamentalSmcAddr: configParse31(configs.get(31)),
+        validatorSets: {
+            prevValidators: configParseValidatorSet(configs.get(32)),
+            prevTempValidators: configParseValidatorSet(configs.get(33)),
+            currentValidators: configParseValidatorSet(configs.get(34)),
+            currentTempValidators: configParseValidatorSet(configs.get(35)),
+            nextValidators: configParseValidatorSet(configs.get(36)),
+            nextTempValidators: configParseValidatorSet(configs.get(37))
+        },
+        validatorsPunish: configParse40(configs.get(40)),
+        suspended: configParse44(configs.get(44)),
+        precompiledContracts: configParse45(configs.get(45)),
+        bridges: {
+            ethereum: configParseBridge(configs.get(71)),
+            binance: configParseBridge(configs.get(72)),
+            polygon: configParseBridge(configs.get(73))
+        },
+        tokenBridges: {
+            ethereum: loadJettonBridgeParams(configs.get(79)),
+            binance: loadJettonBridgeParams(configs.get(81)),
+            polygon: loadJettonBridgeParams(configs.get(82)),
+        }
     };
 }