From 38fab9f9bc105aee18dce5b877920f6acc08c116 Mon Sep 17 00:00:00 2001 From: Mithras Date: Wed, 8 Jan 2025 16:06:44 +0200 Subject: [PATCH] update: JettonLP typings --- src/contracts/ton/pools/tact_JettonLP.ts | 193 +++++++++++++++++++---- 1 file changed, 163 insertions(+), 30 deletions(-) diff --git a/src/contracts/ton/pools/tact_JettonLP.ts b/src/contracts/ton/pools/tact_JettonLP.ts index 3c59e7c..4fb1dbe 100644 --- a/src/contracts/ton/pools/tact_JettonLP.ts +++ b/src/contracts/ton/pools/tact_JettonLP.ts @@ -544,6 +544,26 @@ export function loadBridgeBoilerplate(slice: Slice) { return { $$type: 'BridgeBoilerplate' as const, amount: _amount, payload: _payload }; } +export type Boost = { + $$type: 'Boost'; + amount: bigint; +} + +export function storeBoost(src: Boost) { + return (builder: Builder) => { + let b_0 = builder; + b_0.storeUint(3863699873, 32); + b_0.storeInt(src.amount, 257); + }; +} + +export function loadBoost(slice: Slice) { + let sc_0 = slice; + if (sc_0.loadUint(32) !== 3863699873) { throw Error('Invalid prefix'); } + let _amount = sc_0.loadIntBig(257); + return { $$type: 'Boost' as const, amount: _amount }; +} + export type InternalWithdrawDeposit = { $$type: 'InternalWithdrawDeposit'; amount: bigint; @@ -596,6 +616,66 @@ export function loadInternalWithdrawFee(slice: Slice) { return { $$type: 'InternalWithdrawFee' as const, lastFeeGrowth: _lastFeeGrowth, owner: _owner, balance: _balance }; } +export type LPData = { + $$type: 'LPData'; + apy: bigint; + available_underlying: bigint; + decimals: bigint; + fee_growth_global: bigint; + fee_decimals: bigint; + protocol_fee: bigint; + protocol_fee_amount: bigint; + token_fee: bigint; + total_supply: bigint; +} + +export function storeLPData(src: LPData) { + return (builder: Builder) => { + let b_0 = builder; + b_0.storeInt(src.apy, 257); + b_0.storeInt(src.available_underlying, 257); + b_0.storeInt(src.decimals, 257); + let b_1 = new Builder(); + b_1.storeInt(src.fee_growth_global, 257); + b_1.storeInt(src.fee_decimals, 257); + b_1.storeInt(src.protocol_fee, 257); + let b_2 = new Builder(); + b_2.storeInt(src.protocol_fee_amount, 257); + b_2.storeInt(src.token_fee, 257); + b_2.storeInt(src.total_supply, 257); + b_1.storeRef(b_2.endCell()); + b_0.storeRef(b_1.endCell()); + }; +} + +export function loadLPData(slice: Slice) { + let sc_0 = slice; + let _apy = sc_0.loadIntBig(257); + let _available_underlying = sc_0.loadIntBig(257); + let _decimals = sc_0.loadIntBig(257); + let sc_1 = sc_0.loadRef().beginParse(); + let _fee_growth_global = sc_1.loadIntBig(257); + let _fee_decimals = sc_1.loadIntBig(257); + let _protocol_fee = sc_1.loadIntBig(257); + let sc_2 = sc_1.loadRef().beginParse(); + let _protocol_fee_amount = sc_2.loadIntBig(257); + let _token_fee = sc_2.loadIntBig(257); + let _total_supply = sc_2.loadIntBig(257); + return { $$type: 'LPData' as const, apy: _apy, available_underlying: _available_underlying, decimals: _decimals, fee_growth_global: _fee_growth_global, fee_decimals: _fee_decimals, protocol_fee: _protocol_fee, protocol_fee_amount: _protocol_fee_amount, token_fee: _token_fee, total_supply: _total_supply }; +} +function loadGetterTupleLPData(source: TupleReader) { + let _apy = source.readBigNumber(); + let _available_underlying = source.readBigNumber(); + let _decimals = source.readBigNumber(); + let _fee_growth_global = source.readBigNumber(); + let _fee_decimals = source.readBigNumber(); + let _protocol_fee = source.readBigNumber(); + let _protocol_fee_amount = source.readBigNumber(); + let _token_fee = source.readBigNumber(); + let _total_supply = source.readBigNumber(); + return { $$type: 'LPData' as const, apy: _apy, available_underlying: _available_underlying, decimals: _decimals, fee_growth_global: _fee_growth_global, fee_decimals: _fee_decimals, protocol_fee: _protocol_fee, protocol_fee_amount: _protocol_fee_amount, token_fee: _token_fee, total_supply: _total_supply }; +} + export type ReleaseTokens = { $$type: 'ReleaseTokens'; to: Address; @@ -929,6 +1009,23 @@ export function loadWithdrawCallback(slice: Slice) { return { $$type: 'WithdrawCallback' as const, feeGrowthGlobal: _feeGrowthGlobal, rewards: _rewards }; } +export type WithdrawProtocolFee = { + $$type: 'WithdrawProtocolFee'; +} + +export function storeWithdrawProtocolFee() { + return (builder: Builder) => { + let b_0 = builder; + b_0.storeUint(3742263588, 32); + }; +} + +export function loadWithdrawProtocolFee(slice: Slice) { + let sc_0 = slice; + if (sc_0.loadUint(32) !== 3742263588) { throw Error('Invalid prefix'); } + return { $$type: 'WithdrawProtocolFee' as const }; +} + export type WithdrawStake = { $$type: 'WithdrawStake'; amount: bigint; @@ -1307,6 +1404,7 @@ export type JettonLP$Data = { admin: Address; available_underlying: bigint; bridge: Address; + boost_query_id: bigint; cfo: Address; content: Cell; decimals: bigint; @@ -1333,26 +1431,27 @@ export function storeJettonLP$Data(src: JettonLP$Data) { b_0.storeInt(src.available_underlying, 257); b_0.storeAddress(src.bridge); let b_1 = new Builder(); + b_1.storeInt(src.boost_query_id, 257); b_1.storeAddress(src.cfo); b_1.storeRef(src.content); b_1.storeInt(src.decimals, 257); - b_1.storeInt(src.deployed, 257); - b_1.storeDict(src.deposits, Dictionary.Keys.Address(), dictValueParserPosition()); let b_2 = new Builder(); + b_2.storeInt(src.deployed, 257); + b_2.storeDict(src.deposits, Dictionary.Keys.Address(), dictValueParserPosition()); b_2.storeInt(src.fee_growth_global, 257); b_2.storeInt(src.gas_cost, 257); - b_2.storeInt(src.query_id, 257); - b_2.storeBit(src.mintable); let b_3 = new Builder(); + b_3.storeInt(src.query_id, 257); + b_3.storeBit(src.mintable); b_3.storeAddress(src.owner); b_3.storeInt(src.protocolFee, 257); - b_3.storeInt(src.protocol_fee_amount, 257); - b_3.storeDict(src.roles, Dictionary.Keys.BigInt(257), dictValueParserRoleData()); let b_4 = new Builder(); + b_4.storeInt(src.protocol_fee_amount, 257); + b_4.storeDict(src.roles, Dictionary.Keys.BigInt(257), dictValueParserRoleData()); b_4.storeAddress(src.stake_token); b_4.storeInt(src.tokenFee, 257); - b_4.storeAddress(src.token_wallet); let b_5 = new Builder(); + b_5.storeAddress(src.token_wallet); b_5.storeInt(src.total_supply, 257); b_4.storeRef(b_5.endCell()); b_3.storeRef(b_4.endCell()); @@ -1368,28 +1467,29 @@ export function loadJettonLP$Data(slice: Slice) { let _available_underlying = sc_0.loadIntBig(257); let _bridge = sc_0.loadAddress(); let sc_1 = sc_0.loadRef().beginParse(); + let _boost_query_id = sc_1.loadIntBig(257); let _cfo = sc_1.loadAddress(); let _content = sc_1.loadRef(); let _decimals = sc_1.loadIntBig(257); - let _deployed = sc_1.loadIntBig(257); - let _deposits = Dictionary.load(Dictionary.Keys.Address(), dictValueParserPosition(), sc_1); let sc_2 = sc_1.loadRef().beginParse(); + let _deployed = sc_2.loadIntBig(257); + let _deposits = Dictionary.load(Dictionary.Keys.Address(), dictValueParserPosition(), sc_2); let _fee_growth_global = sc_2.loadIntBig(257); let _gas_cost = sc_2.loadIntBig(257); - let _query_id = sc_2.loadIntBig(257); - let _mintable = sc_2.loadBit(); let sc_3 = sc_2.loadRef().beginParse(); + let _query_id = sc_3.loadIntBig(257); + let _mintable = sc_3.loadBit(); let _owner = sc_3.loadAddress(); let _protocolFee = sc_3.loadIntBig(257); - let _protocol_fee_amount = sc_3.loadIntBig(257); - let _roles = Dictionary.load(Dictionary.Keys.BigInt(257), dictValueParserRoleData(), sc_3); let sc_4 = sc_3.loadRef().beginParse(); + let _protocol_fee_amount = sc_4.loadIntBig(257); + let _roles = Dictionary.load(Dictionary.Keys.BigInt(257), dictValueParserRoleData(), sc_4); let _stake_token = sc_4.loadAddress(); let _tokenFee = sc_4.loadIntBig(257); - let _token_wallet = sc_4.loadAddress(); let sc_5 = sc_4.loadRef().beginParse(); + let _token_wallet = sc_5.loadAddress(); let _total_supply = sc_5.loadIntBig(257); - return { $$type: 'JettonLP$Data' as const, admin: _admin, available_underlying: _available_underlying, bridge: _bridge, cfo: _cfo, content: _content, decimals: _decimals, deployed: _deployed, deposits: _deposits, fee_growth_global: _fee_growth_global, gas_cost: _gas_cost, query_id: _query_id, mintable: _mintable, owner: _owner, protocolFee: _protocolFee, protocol_fee_amount: _protocol_fee_amount, roles: _roles, stake_token: _stake_token, tokenFee: _tokenFee, token_wallet: _token_wallet, total_supply: _total_supply }; + return { $$type: 'JettonLP$Data' as const, admin: _admin, available_underlying: _available_underlying, bridge: _bridge, boost_query_id: _boost_query_id, cfo: _cfo, content: _content, decimals: _decimals, deployed: _deployed, deposits: _deposits, fee_growth_global: _fee_growth_global, gas_cost: _gas_cost, query_id: _query_id, mintable: _mintable, owner: _owner, protocolFee: _protocolFee, protocol_fee_amount: _protocol_fee_amount, roles: _roles, stake_token: _stake_token, tokenFee: _tokenFee, token_wallet: _token_wallet, total_supply: _total_supply }; } type JettonLP_init_args = { @@ -1423,8 +1523,8 @@ function initJettonLP_init_args(src: JettonLP_init_args) { } async function JettonLP_init(admin: Address, cfo: Address, bridge: Address, stake_token: Address, decimals: bigint, protocolFee: bigint, tokenFee: bigint, content: Cell) { - const __code = Cell.fromBase64('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'); - const __system = Cell.fromBase64('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'); + const __code = Cell.fromBase64('te6ccgEC3AEAOlUAART/APSkE/S88sgLAQIBYgIDA8rQAdDTAwFxsKMB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiFRQUwNvBPhhAvhi2zwRFBEWERQRExEVERMREhEUERIRERETEREREBESERAPEREPDhEQDhDfVRzbPPLggscGBwIBIAQFAgEgd3gCASCZmgTuAZIwf+BwIddJwh+VMCDXCx/eIMAAItdJwSGwklt/4CCCEOZLYaG6jpgw0x8BghDmS2GhuvLggYEBAdcAATHbPH/gIIIQI+OzJLqOmDDTHwGCECPjsyS68uCBgQEB1wABMds8f+AgghDfDmkkuuMCIIIQc2LQnLoLDA0OATjI+EMBzH8BygARFREUERMREhERERBV4Ns8ye1UCAH2AREVAREUINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WARESAYEBAc8AAREQINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WDsiBAQHPAFANINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WG8wZgQEBCQH0zwAHyIEBAc8AFvQAFIEBAc8AEoEBAc8AAciBAQHPABLKAFgg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxYTgQEBzwADyIEBAc8AFPQAUAUg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxYVgQEBzwDIUAcKAGgg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxYVgQEBzwDJUAXMyVjMyQHMyQHMyQHMAfCBKmSBAQv4QlYQWVn0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4m6z8vSCAJCH+EIRFREXERURFBEWERQRExEXERMREhEWERIREREXEREREBEWERAPERcPDhEWDg0RFw0MERYMCxEXCwoRFgoPA/YRFBEVERQRExEVERMREhEVERIREREVEREREBEVERAPERUPDhEVDg0RFQ0MERUMCxEVCwoRFQoJERUJERUIBwZVQNs8ggCd9PgnbxBWF77y9FYQAREWcXBVIG1tbds8MBETERQRExESERMREhERERIREREQEREREA8REA9eZxIBJjDTHwGCEN8OaSS68uCBbTHbPH8TBNCOyTDTHwGCEHNi0Jy68uCB0z/6APpAASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IhUEwMQI2wUMDKBZoH4QlJQxwXy9AHbPH/gIIIQChn+nrrjAiCCEHvdl9664wIgghAy0g+muhUWFxgD+gkRFwkIERYIBxEXBwYRFgYFERcFBBEWBAMRFwMCERYCAREXAds8VxIREVYVvgERFgHy9Cek+EIRFBEVERQRExEUERMREhETERIBERIBERAREREQDxEQDxDvEN4QzRC8EKsQmhCJEHgQZxBWEEUQNBAjAhEWAgERFgFWFts8sUMQAUwRFBEVERQRExEUERMREhETERIRERESEREREBERERAPERAPVQ7bPBEAFlHMoAERFAEMoBETAARVDgP2MNs8ggCXPCbCAPL0CaTIghAPin6lAcsfUhDLPyb6AlYRINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WVhEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxZtAfQAK/oCbQH0AMkrqgAjWXF/BANtbds8MFYQXmcUAKwmyFmCEOhLBJJQA8sfASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFoEBAc8AyciCWMAAAAAAAAAAAAAAAAEBy2fMyXD7AAEREwEFoRESEEhwBQEqgUPtIsIA8vQRFSGg+CgBERYBEts8GQGGMNMfAYIQChn+nrry4IH6QAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIAYEBAdcA0gABkdSSbQHiVSBsE9s8fx0BzjDTHwGCEHvdl9668uCB0z/6APpAASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IgBINcLAcMAjh/6QAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIlHLXIW3iFEMwbBTbPH8kBJ6PGzDTHwGCEDLSD6a68uCBbTEA2zwgwgCRMOMNf+AgghDVMnbbuo4UMNMfAYIQ1TJ227ry4IHTPwExMH/gIIIQugeRLbrjAiCCEGBZFRC6LS4vMAK+gV3iLPL0UTGgDKQRFREXERURFBEWERQRExEXERMREhEWERIREREXEREREBEWERAPERcPDhEWDg0RFw0MERYMCxEXCwoJERcJCAcRFwcGBREXBQQDERcDAgERFgHbPFy4GgP+cFnIcAHLAXMBywFwAcsAEszMyfkAyHIBywFwAcsAEsoHy//J0CDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4Ihwf4BA+CgjyMnQVhIFBBEfBBEgWchVUNs8yUZQBBEbBAMRGgMCAREbAREaEEYQRds8MBESERQREhERERMRERtnHADAghAXjUUZUAfLHxXLP1AD+gIBINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WASBulTBwAcsBjh4g10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxbiAfoCAc8WACAREBESERAPEREPDhEQDlUdAvQiWQARFxEYERcRFhEYERYRFREYERURFBEYERQRExEYERMREhEYERIREREYEREREBEYERAPERgPDhEYDg0RGA0MERgMCxEYCwoRGAoJERgJCBEYCAcRGAcGERgGBREYBQQRGAQDERgD2zwLpMiCEA+KfqUByx9SEMs/Ih4fAfIyVhZWFlYWVhZWFlYWVhZWFlYWVhZWFlYWVhZWFlYWVhZWFlYWVhZWFlYW+EFvJBAjXwMRFBEsERQRExErERMREhEqERIREREpEREREBEoERAPEScPDhEmDg0RJQ0MESQMCxEjCwoRIgoJESEJCBEgCAcRHwcGER4GIAGe+gJWGCDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFlYYINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WbQH0AC36Ahz0AMkRFyME/gURHQUEERwEAxEbAwIRGgIBERkBERjbPFcQXw9sUQERFgERFREYERURFBEXERQBERMBERIRGBESERERFxERAREQAQ8RGA8OERcOHQwRGAwLERcLGgkRGAkIERcIFwYRGAYFERcFFAMRGAMCERcC2zyBaFAB8vRWFds8UXGgUnLSgiEiAD4nwgCYUweogScQqQSRcOIkwgCYURSogScQqQSSMXDiAMihHaDIyVYYbrOaMBEXIG7y0IARF5JXGOJWFiehAREVAaEBERYBBqEBERYRFBEWERQFERUFERIRFBESERERExERERAREhEQDxERDw4REA4Q3xDOEKwQmxCKEHkQaBBGEDUQJBAjAfDIWYIQ9bcelFADyx+BAQHPAAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxbJyIJYwAAAAAAAAAAAAAAAAQHLZ8zJcPsAKqoAIgIRFwFxfwQDbW3bPDARExEUERMREhETERIRERESEREREBERERAPERAPVQ5nAvBUYzBSMAARGBEbERgRFxEaERcRFhEZERYRFREbERURFBEaERQRExEZERMREhEbERIREREaEREREBEZERAPERsPDhEaDg0RGQ0MERsMCxEaCwoRGQoJERsJCBEaCAcRGQcGERsGBREaBQQRGQTbPBETVhahVhdWEr0lJgLiMDIRFBEWERQRExEVERMREhEWERIREREVEREREBEWERAPERUPDhEWDg0RFQ0MERYMCxEVCwoRFgoJERUJCBEWCAcRFQcGERYGBREVBQQRFgQDERUDAhEWAgERFQERFlYV2zwsgQELVhdZ9AtvoZIwbd8nKAKSnFcRVxVXFQ4RFA5wD+MNcHCAQCrIAYIQ1TJ221jLH8s/yQQRFwQQJBAjbW3bPDAREREUERERERETEREPERIPDhERDg0REA1VLCxnAvaBOoX4QW8kECNfAxEVERcRFREUERYRFBETERcRExESERYREhERERcREREQERYREA8RFw8OERYODREXDQwRFgwLERcLChEWCgkRFwkIERYIBxEXBwYRFgYFERcFBBEWBAMRFwMCERYCAREXAREW2zwBERYBxwUBERYB8vS3KQH8IG6SMG2OFtCBAQHXAIEBAdcAgQEB1wBVIGwTbwPibpaCAIen8vDeIFYXvjAsgQELVhdZ9AtvoZIwbd8gbpIwbY4W0IEBAdcAgQEB1wCBAQHXAFUgbBNvA+IgbvLQgG8jERQRFxEUERMRFhETERIRFRESERERFxERERARFhEQKgA8ERIRFBESERERExERERAREhEQDxERDw4REA4Q31UcAv4PERUPDhEXDg0RFg0MERUMCxEXCwoRFgoJERUJCBEXCAcRFgcGERUGBREXBQQRFgQDERUDAhEXAgERFgERFVYY2zwBERYBoBEXVhmhAREVAREZoQIRGAIBERUBERZvAxERERYREREQERUREA8RFA8OERMODRESDQwREQwLERALrysBLBCvEJ4QjRB8EGsQWhBJEDhHYBAl2zw8AeDIghAPin6lAcsfAREYAcs/AREW+gJWFCDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFlYUINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WbQH0ACn6Am0B9ADJKaoAVhZZcX8EA21t2zwwZwH0MIEBC/hCLllZ9AtvoZIwbd8gbpIwbY4W0IEBAdcAgQEB1wCBAQHXAFUgbBNvA+JulYFyZfLw3oEBC/hCLllZ9AtvoZIwbd8gbpIwbY4W0IEBAdcAgQEB1wCBAQHXAFUgbBNvA+IgbvLQgG8j+EIRFREYERURFBEXERQxAe4KpBEUKqHIghAPin6lAcsfVhUByz9QC/oC+EIg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxb4QiDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFm0B9AAr+gJtAfQAySuqACNZcX8EA21t2zwwCRETCWcBsjDTHwGCELoHkS268uCBgQEB1wD6QAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIAfpAASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IhDMGwT2zx/NATSjpgw0x8BghBgWRUQuvLggYEBAdcAATHbPH/gIIIQobw2YrqOsTDTHwGCEKG8NmK68uCB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiDHbPH/gIIIQ0ynug7rjAiCCEPr4Sn26Pj9AQQP8ERMRFhETERIRGBESERERFxERERARFhEQDxEYDw4RFw4NERYNDBEYDAsRFwsKERYKCREYCQgRFwgHERYHBhEYBgURFwUEERYEAxEYAwIRFwIBERYB2zwBERYBoCDAAOMCgSyHVhQivvL0UbuhcPhCAhEZAhEYAW8DERQRFhEUrzIzAEQwVxVXFRERERQREREQERMREA8REg8OEREODREQDRDPVStwAdARExEVERMREhEUERIRERETEREREBESERAPEREPDhEQDhDfEM4NERcNEKwQmxCKEHkQaBBXEEYQNUQwAhEXAgERFwHbPBEUERURFBETERQRExESERMREhERERIREREQEREREA8REA9VDjwC9BEUERcRFBETERYRExESERUREhERERcREREQERYREA8RFQ8OERcODREWDQwRFQwLERcLChEWCgkRFQkIERcIBxEWBwYRFQYFERcFBBEWBAMRFQMCERcCAREWAREVVhXbPIIAo1n4QhLHBfL0LIEBC1YXWfQLb6GSMG3ftjUD9CBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4m6OqBEUERURFBETERQRExESERMREhERERIREREQEREREA8REA9VDlYX2zzjDiyBAQtWF1n0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4m6zNjc4AFqBAQtRHnDIVSBQI4EBAc8AgQEBzwCBAQHPAMkQPxIgbpUwWfRZMJRBM/QT4gwB/CyBAQtWF1n0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4iBu8tCAbyMRFBEXERQRExEWERMREhEVERIREREXEREREBEWERAPERUPDhEXDg0RFg0MERUMCxEXCwoRFgoJERUJCBEXCAcRFgcGERUGBREXBTkBSpRXFVcV4w0REhEUERIRERETEREREBESERAPEREPDhEQDhDfVRw6AsgEERYEAxEVAwIRFwIBERYBERVWGNs8AREWAaARF1YaoAIBERYBERdvAxESERYREhERERUREREQERQREA8REw8OERIODRERDQwREAwQvxCuEJ0QjBB7EGoQWRBIEDdGUBRDMNs8rzwB/CyBAQtWF1n0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4iBu8tCAbyMRFBEXERQRExEWERMREhEVERIREREXEREREBEWERAPERUPDhEXDg0RFg0MERUMCxEXCwoRFgoJERUJCBEXCAcRFgcGERUGBREXBTsC7AQRFgQDERUDAhEXAgERFgERFVYY2zwBERYBoAERFwERGaECAREVAREYbwMREREWEREREBEVERAPERQPDhETDg0REg0MEREMCxEQCxCvEJ4QjRB8EGsQWhBJEDhHYBAlECPbPAERFAEREwEREgEREQEREAEPVcGvPAGSICBu8tCAbyMxAm6Rf5ogwACTIcAAkXDi4o4rLoEBCwPIVSBQI4EBAc8AgQEBzwCBAQHPAMkQPxIgbpUwWfRZMJRBM/QT4uMNDD0AdFuBAQttIG6SMG2OHCBu8tCAbyPIVSBQI4EBAc8AgQEBzwCBAQHPAMniED8SIG6VMFn0WTCUQTP0E+IB8oIAyuYhwgDy9IEBC/hCL1lZ9AtvoZIwbd8gbpIwbY4W0IEBAdcAgQEB1wCBAQHXAFUgbBNvA+JulYFyZfLw3oIAkIf4QhEVERcRFREUERYRFBETERcRExESERYREhERERcREREQERYREA8RFw8OERYODREXDQwRFgxCAvIRFBEVERQRExEVERMREhEVERIREREVEREREBEVERAPERUPDhEVDg0RFQ0MERUMCxEVCwoRFQoJERUJERUIBwZVQNs8VhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUERQRKREUERMRKBETb0UBYjDTHwGCENMp7oO68uCB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiDHbPH9JBP6OsTDTHwGCEPr4Sn268uCB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiDHbPH/gIIIQNhYgZ7qOrjDTHwGCEDYWIGe68uCB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiDHgIIIQCFLVHLrjAiCCEBuZBIe6T1BRUgLyCxEXCwoRFgoJERcJCBEWCAcRFwcGERYGBREXBQQRFgQDERcDAhEWAgERFwHbPFYWvgERFwHy9PhCERQRFhEUERMRFRETERIRFBESERERExERERAREhEQDxERDw4REA4Q3xDOEL0QrBCbEIoQeRBoEFcQRhA1RAPbPLFDApQLpBEVERYRFREUERYRFBETERYRExESERYREhERERYREREQERYREA8RFg8OERYODREWDQwRFgwLERYLVZDbPHB/gED4KC4CERsBbbdEAfjIVTCCEFlfB7xQBcsfE8s/AfoCASBulTBwAcsBjh4g10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxbiIW6zlX8BygDMlHAyygDiyRA0QTABERkBECQQI21t2zwwERMRFBETERIRExESEREREhERERAREREQDxEQD1UOZwK0ERIRJxESERERJhERERARJREQDxEkDw4RIw4NESINDBEhDAsRIAsKER8KCREeCQgRHQgHERwHBhEbBgURGgUEERkEAxEYAwIRFwIBERYBERXbPFcQXw9sUVYW2kYC/iaBAQEjWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuIgbuMAIG7y0IBvIoEBC1ADf3EhbpVbWfRZMJjIAc8AQTP0QeKBAQECyFkC9ACBAQHPAMkQNxIgbpUwWfRaMJRBM/QV4gRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhTZRwLuVhRWFFYUVhRWFFYUVhRWFFYUERQRKREUERMRKBETERIRJxESERERJhERERARJREQDxEkDw4RIw4NESINDBEhDAsRIAsKER8KCREeCQgRHQgHERwHBhEbBgURGgUEERkEAxEYAwIRFwIBERYBERXbPFcQXw9sQQHaSAH+JoEBASNZ9A1voZIwbd8gbpIwbZ3Q9ASBAQHXAFlsEm8C4oELbyFus/L0IG7y0IBvIoEBC1ADcHEhbpVbWfRZMJjIAc8AQTP0QeKBAQECyFkC9ACBAQHPAMkQNxIgbpUwWfRaMJRBM/QV4gRXFBESERMREhERERIREREQEREREFcC8hEUERURFBETERURExESERUREhERERUREREQERUREA8RFQ8OERUODREVDQwRFQwLERULChEVCgkRFQkRFQgHBlVA2zxWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhQRFBEpERQRExEoERNvSgK0ERIRJxESERERJhERERARJREQDxEkDw4RIw4NESINDBEhDAsRIAsKER8KCREeCQgRHQgHERwHBhEbBgURGgUEERkEAxEYAwIRFwIBERYBERXbPFcQXw9sUVYW1ksC/iaBAQEjWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuIgbuMAIG7y0IBvIoEBC1ADf3EhbpVbWfRZMJjIAc8AQTP0QeKBAQECyFkC9ACBAQHPAMkQNxIgbpUwWfRaMJRBM/QV4gRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhTZTALuVhRWFFYUVhRWFFYUVhRWFFYUERQRKREUERMRKBETERIRJxESERERJhERERARJREQDxEkDw4RIw4NESINDBEhDAsRIAsKER8KCREeCQgRHQgHERwHBhEbBgURGgUEERkEAxEYAwIRFwIBERYBERXbPFcQXw81M1vWTQH+JoEBASNZ9A1voZIwbd8gbpIwbZ3Q9ASBAQHXAFlsEm8C4oELbyFus/L0IG7y0IBvIoEBC1ADcHEhbpVbWfRZMJjIAc8AQTP0QeKBAQECyFkC9ACBAQHPAMkQNxIgbpUwWfRaMJRBM/QV4gRXEBETERQRExESERMREhERERIREU4AEBEQEREREFUOAvIRFBEVERQRExEVERMREhEVERIREREVEREREBEVERAPERUPDhEVDg0RFQ0MERUMCxEVCwoRFQoJERUJERUIBwZVQNs8VhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUERQRKREUERMRKBETb1MB9hEUERURFBETERURExESERUREhERERUREREQERUREA8RFQ8OERUODREVDQwRFQwLERULChEVCgkRFQkRFQgHBlVA2zwxERMRFBETERIRExESEREREhERERAREREQDxEQDxDvEN4QzRC8EKsQmhCJEHgQZxBWEEUQNEEwf28BPDDTHwGCEAhS1Ry68uCBgQEB1wCBAQHXAFlsEts8f1gEuo6VMNMfAYIQG5kEh7ry4IGBAQHXAAEx4CCCEJRqmLa6jqgw0x8BghCUapi2uvLggdM/ATHIAYIQr/kPV1jLH8s/yfhCAXBt2zx/4CCCEK8comq64wIgghAsdrlzulpbXF0CtBESEScREhERESYREREQESUREA8RJA8OESMODREiDQwRIQwLESALChEfCgkRHgkIER0IBxEcBwYRGwYFERoFBBEZBAMRGAMCERcCAREWAREV2zxXEF8PbFFWFtJUAv4mgQEBI1n0DW+hkjBt3yBukjBtndD0BIEBAdcAWWwSbwLiIG7jACBu8tCAbyKBAQtQA39xIW6VW1n0WTCYyAHPAEEz9EHigQEBAshZAvQAgQEBzwDJEDcSIG6VMFn0WjCUQTP0FeIEVhRWFFYUVhRWFFYUVhRWFFYUVhRWFFYU2VUC7lYUVhRWFFYUVhRWFFYUVhRWFBEUESkRFBETESgRExESEScREhERESYREREQESUREA8RJA8OESMODREiDQwRIQwLESALChEfCgkRHgkIER0IBxEcBwYRGwYFERoFBBEZBAMRGAMCERcCAREWAREV2zxXEF8PNVsx0lYB/iaBAQEjWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuKBC28hbrPy9CBu8tCAbyKBAQtQA3BxIW6VW1n0WTCYyAHPAEEz9EHigQEBAshZAvQAgQEBzwDJEDcSIG6VMFn0WjCUQTP0FeIEVxIRExEUERMREhETERIREBERERBXAAwPERAPVQ4C7BEUERYRFBETERURExESERYREhERERUREREQERYREA8RFQ8OERYODREVDQwRFgwLERULChEWCgkRFQkIERYIBxEVBwYRFgYFERUFBBEWBAMRFQMCERYCAREVAREW2zwyNYFzC1YUVha78vQREhEUERIRERETERFeWQBOERAREhEQDxERDw4REA4Q3xDOEL0QrBCbEIoQeRBoEFcQVhA1RDASAe4RFBEVERQRExEVERMREhEVERIREREVEREREBEVERAPERUPDhEVDg0RFQ0MERUMCxEVCwoRFQoJERUJERUIBwZVQNs8OoIAg4FWFcIA8vQRExEUERMREhETERIRERESEREREBERERAPERAPEO8Q3hDNELwQq1UIf14BPG1tIm6zmVsgbvLQgG8iAZEy4hAkcAMEgEJQI9s8MGcB6DDTHwGCEK8comq68uCB1AExERQRFREUERMRFRETERIRFRESERERFRERERARFREQDxEVDw4RFQ4NERUNDBEVDAsRFQsKERUKCREVCREVCAcGVUDbPD8RExEUERMREhETERIRERESEREREBERERAPERAPVQ1/YAP8jrYw0x8BghAsdrlzuvLggdM/+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAHSAFUgbBPgIIIQCmHbWbqOuTDTHwGCEAph21m68uCB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAGBAQHXAFlsEts8f+AgYWJjAt4kERMRFRETERIRFBESERERFRERERARFBEQDxEVDw4RFA4NERUNDBEUDAsRFQsKERQKCREVCQgRFAgHERUHBhEUBgURFQUEERQEAxEVAwIRFAIBERUBERSBAQERFts8AhEWAgERFwFZ9A1voZIwbd/WXwDiIG6SMG2d0PQEgQEB1wBZbBJvAuKCANFNIW6z8vQgbvLQgG8iMIEBC/hBbyQQI18DcUEz9ApvoZQB1wAwkltt4oEYKyFus5gBIG7y0IDA/5IxcOLy9BESERQREhERERMREREQERIREA8REQ8OERAOVR0AEvhCUoDHBfLghAPkgUf9+EFvJBNfA4IIXRQgvvL0+EP4KFIw2zwCjtIy+EJwA4BAA3BZyHABywFzAcsBcAHLABLMzMn5AMhyAcsBcAHLABLKB8v/ydAg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIyHABygDJ0BAl4w1/uWRlAuwRFBEWERQRExEVERMREhEWERIREREVEREREBEWERAPERUPDhEWDg0RFQ0MERYMCxEVCwoRFgoJERUJCBEWCAcRFQcGERYGBREVBQQRFgQDERUDAhEWAgERFQERFts8ERQRFhEUERMRFRETERIRFBESERERExERb2kDsIIQUT7zXrqOuTDTHwGCEFE+81668uCB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAGBAQHXAFlsEts8f+AgghAXMr4huuMCghAk+kfJuuMCMHBsbW4BdshVIIIQ0XNUAFAEyx8Syz8BINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WAc8WyX9VMG1t2zwwZwHi+EJwAoBABHBZyHABywFzAcsBcAHLABLMzMn5AMhyAcsBcAHLABLKB8v/ydAg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIyH8BygBQBSDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFsnQRUBmAXrIVSCCENFzVABQBMsfEss/ASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFgHPFskQI39VMG1t2zwwZwHKyHEBygFQBwHKAHABygJQBSDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjPFlAD+gJwAcpoI26zkX+TJG6z4pczMwFwAcoA4w0hbrOcfwHKAAEgbvLQgAHMlTFwAcoA4skB+whoAJh/AcoAyHABygBwAcoAJG6znX8BygAEIG7y0IBQBMyWNANwAcoA4iRus51/AcoABCBu8tCAUATMljQDcAHKAOJwAcoAAn8BygACyVjMASgREBESERAPEREPDhEQDhDfVRzbPGoD4hEUERYRFBETERURExESERYREhERERUREREQERYREA8RFQ8OERYODREVDQwRFgwLERULChEWCgkRFQkIERYIBxEVBwYRFgYFERUFBBEWBAMRFQMCERYCAREVAREWVhXbPNs8JIEBAVYXWfQNb6GSMG3fkHNrAf4gbpIwbZ3Q9ASBAQHXAFlsEm8C4iBu8tCAbyKBAQsBERl/cSFulVtZ9FkwmMgBzwBBM/RB4oEBAREYyFkC9ACBAQHPAMkQNQIRFwIBERYBIG6VMFn0WjCUQTP0FeIREhEUERIRERETEREREBESERAPEREPDhEQDhDfEM4QvRCsdgLsERQRFhEUERMRFRETERIRFhESERERFRERERARFhEQDxEVDw4RFg4NERUNDBEWDAsRFQsKERYKCREVCQgRFggHERUHBhEWBgURFQUEERYEAxEVAwIRFgIBERUBERbbPBEUERYRFBETERURExESERQREhERERMREW9wAZAw0x8BghAXMr4huvLggYEBAdcA+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiBJsEoEfC/hBbyQQI18DIscF8vTbPH9yANzTHwGCECT6R8m68uCBgQEB1wCBAQHXAFlsEiaBAQEjWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuKBVOUhbrPy9CBu8tCAbyIwgQEBAshZAvQAgQEBzwDJEDcSIG6VMFn0WjCUQTP0FeIEfwLeJBETERURExESERQREhERERUREREQERQREA8RFQ8OERQODREVDQwRFAwLERULChEUCgkRFQkIERQIBxEVBwYRFAYFERUFBBEUBAMRFQMCERQCAREVAREUgQEBERbbPAIRFgIBERcBWfQNb6GSMG3f2nEBKBEQERIREA8REQ8OERAOEN9VHNs8cgDgIG6SMG2d0PQEgQEB1wBZbBJvAuKBFZQhbrPy9CBu8tCAbyIwgQEL+EFvJBAjXwNxQTP0Cm+hlAHXADCSW23igUKPIW6zmAEgbvLQgMD/kjFw4vL0ERIRFBESERERExERERAREhEQDxERDw4REA5VHQPiERQRFhEUERMRFRETERIRFhESERERFRERERARFhEQDxEVDw4RFg4NERUNDBEWDAsRFQsKERYKCREVCQgRFggHERUHBhEWBgURFQUEERYEAxEVAwIRFgIBERUBERZWFds82zwkgQEBVhdZ9A1voZIwbd+Qc3QC8oIAxO34QW8kECNfAxEWERcRFhEVERcRFREUERcRFBETERcRExESERcREhERERcREREQERcREA8RFw8OERcODREXDQwRFwwLERcLChEXCgkRFwkIERcIBxEXBwYRFwYFERcFBBEXBAMRFwMCERcCAREX2zwBERYB8vSCdQH+IG6SMG2d0PQEgQEB1wBZbBJvAuIgbvLQgG8igQELAREZcHEhbpVbWfRZMJjIAc8AQTP0QeKBAQERGMhZAvQAgQEBzwDJEDUCERcCAREWASBulTBZ9FowlEEz9BXiERIRFBESERERExERERAREhEQDxERDw4REA4Q3xDOEL0QrHYAPBETERQRExESERMREhERERIREREQEREREA8REA9VDgAiEJsQihB5EGgQVxBGEDVQRAMCASB+fwIBIHl6AgEge3wCGbe9m2ebZ4riC+HtijDHfQIBZo2OAgEgkZIABFYQAgFIgIECASCDhAIBIIaHAqOs1oCQa6TAgIXdeXBEEGuFhRBAgn/deWhEwYTdeXBEbZ4IigiLCIoIiYiKiImIiQiKCIkIiIiJiIiIiAiJCIgHiIiHhwiIByqO7Z4riC+HtijAx4IAnoEBAScCWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuIgbpJbcOAgbvLQgG8iMIEBC1hxQTP0Cm+hlAHXADCSW23iIG6SMHDgIG7y0IACGbLpds82zxXEF8PbFGDHhQIBIIqLAAIpAhiqfNs82zxXEF8PbFHHiAIYqDvbPNs8VxBfD2xRx4kAAiMAAiECFa5E7Z5tnjZMtmTAx4wCGa1ebZ5tniuIL4e2KMDH1gEoVH7bVCIw2zxWFFYQLoEnEFR7pyiUAhemO7Z5tniuIL4e2KPHjwJfpiO2eCIoIioiKCImIigiJiIkIiYiJCIiIiQiIiIgIiIiIB4iIB6qHbZ4riC+Htijx5AAAicAZIEBASYCWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuKBVOUhbrPy9CBu8tCAbyIxAhmseG2ebZ4riC+HtijAx5MCGaxd7Z5tniuIL4e2KMDH2gEQVH7bVCIw2zyUAfR6UAMgwv/yhXEBkiGo5DFcuZF/k1MgueKRf44QXKkEwgCzllMgqQTCAJFw4uKTXwRw4BEVERgRFREUERcRFBETERYRExESERgREhERERcREREQERYREA8RGA8OERcODREWDQwRGAwLERcLChEWCgkRGAkIERcIBxEWB5UC/AYRGAYFERcFBBEWBAMRGAMCERcCAREWAREY2zwRF1YYqIEnEKgBERapBFYWqQSBJxCpBFYXAaBWF3ARGJshqFYYqQQRF6QRF+QxVxYRFVYWoYEnEKgBERapBBESERUREhERERQREREQERMREA8REg8OEREODREQDRDPEL4QrZaXATLbPCDBAZIwcd4ggQFtvJIwcZaBAW0BqQTimAAgEJwQixB6EGkQWBBHEDZFQAA2+CNcvJJbcOABoYIBUYCpBCCBAW28lDCBAW3eAgEgm5wCASCgoQIBWKWmAgEgnZ4CGbEjNs82zxXEF8PbFGDHnwIBWLq7AAIuAgEgvr8CASCiowIBWMTFAhmyrLbPNs8VxBfD2xRgx6QABFYTAgFmp6gCFa8W7Z5tnjZ6tjLAx6sCAW6pqgIBILS1ApevSDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjbPBEUERURFBETERQRExESERMREhERERIREREQEREREA8REA9VDts8VxBfD2xRgx6wCk6sINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiNs8ERQRFREUERMRFBETERIRExESEREREhERERAREREQDxEQD1UO2zxs82xjgx60BIvhD+ChSkNs8MFRhoFKgVhMBuQEE2zyvAfQtgQELIln0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4m6UMHBTAOAtgQELIln0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4iBu8tCAbyNbLREVERcRFREUERYRFBETERcRE64C/BESERYREhERERcREREQERYREA8RFw8OERYODREXDQwRFgwLERcLChEWCgkRFwkIERYIBxEXBwYRFgYFERcFBBEWBAMRFwMCERYCAREXAREW2zwCERcCAREWAREVERcRFREUERYRFBETERURExESERQREhERERMREREQERIREK+wAvYtgQELIln0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4m6SMHDgERQRFREUERMRFRETERIRFRESERERFRERERARFREQDxEVDw4RFQ4NERUNDBEVDAsRFQsKERUKCREVCREVCAcGVUBWFds8gQELLgKxsgBADxERDw4REA4Q3xDOEL0QrBCbEIoQeRBoEFcQRhA1EDQAyi2BAQsiWfQLb6GSMG3fIG6SMG2OFtCBAQHXAIEBAdcAgQEB1wBVIGwTbwPibpIwcOCBAQsuAln0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4iBu8tCAbyNbAf4RGFn0C2+hkjBt3yBukjBtjhbQgQEB1wCBAQHXAIEBAdcAVSBsE28D4iBu8tCAbyMwMVLAoSDCAI5FAREWAahWFakEERQRFREUERMRFBETERIRExESEREREhERERAREREQDxEQDxDvEN4QzRC8EKsQmhCJEHgQZxBWEEUQNEEwswBG4DBXFRETERQRExESERMREhERERIREREQEREREA8REA9VDnACl7+SDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IjbPBEUERURFBETERQRExESERMREhERERIREREQEREREA8REA9VDts8VxBfD2xRjHtgIXuZ2zzbPFcQXw9sUYx9IBBNs8twGG2zxwWchwAcsBcwHLAXABywASzMzJ+QDIcgHLAXABywASygfL/8nQINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiLgBDvhD+CgS2zy5ANYC0PQEMG0BgTSOAYAQ9A9vofLghwGBNI4iAoAQ9BfIAcj0AMkBzHABygBAA1kg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIzxYBINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiM8WyQIYqfbbPNs8VxBfD2xRx7wCGKj62zzbPFcQXw9sUce9AARWFAACIgIBYsDBAhmz/bbPNs8VxBfD2xRgx8MCF6Uttnm2eK4gvh7Yo8fCAA+lfdqJoaQAAwACJgACIAIYqtvbPNs8VxBfD2xRx8YCGKk+2zzbPFcQXw9sUcfIAAIlA4TtRNDUAfhj0gABjqLbPFcVERMRFBETERIRExESEREREhERERAREREQDxEQD1UO4Pgo1wsKgwm68uCJ2zwI0VUG2zzJyssAAisB9vpAASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IgBgQEB1wD6QAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIAdQB0IEBAdcA+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAHUgQEB1wDUMNCBAQHXAMwBxvpAASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IgB+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAH6QAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIAdQB0M4B7G1tggCEn1NUu/L0U5dwK/hCUyJ/IfgjUxGNCGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCCcnDgFR9XFPtVhVWGStWF1PJVhJWElYWViBWEVYeViVWI1YUVhwRFBEiERQRExEaERMREhEhERLPAdr0BIEBAdcAgQEB1wDUMNCBAQHXANIA+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAGBAQHXANQw0IEBAdcA9AT6QAEg10mBAQu68uCIINcLCiCBBP+68tCJgwm68uCIAYEBAdcA1DDQzQBw+kABINdJgQELuvLgiCDXCwoggQT/uvLQiYMJuvLgiAGBAQHXADAREhEVERIREhEUERIREhETERIAdPpAASDXSYEBC7ry4Igg1wsKIIEE/7ry0ImDCbry4IgBgQEB1wCBAQHXANQw0IEBAdcA1DAQWBBXEFYC/BERESAREREQER8REA8RJQ8OESgODREZDQwRJAwLERgLChEVCgkRHAkIERsIBxEeBwYRJwYFERcFBBEjBAMRKQMCESYCAREWAREd2zxXEF8PbFEOERYOBhEVBg0RFA0MERMMCxESCw0REA0QXxDeEE0cEIsQehB5GBA3EFZDBNrQAv4RGCaBAQEjWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuIgbuMAIG7y0IBvIoEBC1ADf3EhbpVbWfRZMJjIAc8AQTP0QeKBAQECyFkC9ACBAQHPAMkQNxIgbpUwWfRaMJRBM/QV4gRWFFYUVhRWFFYUVhRWFFYUVhRWFFYU2dEC/FYUVhRWFFYUVhRWFFYUVhRWFFYUERQRKREUERMRKBETERIRJxESERERJhERERARJREQDxEkDw4RIw4NESINDBEhDAsRIAsKER8KCREeCQgRHQgHERwHBhEbBgURGgUEERkEAxEYAwIRFwIBERYBERXbPFcQXw9sUREVERYRFdLTAESC8O8wT76rE/5r4WDXhfzsqlYgyEbnrWl+KRW/4GEvqctnAUwRFBEVERQRExEUERMREhETERIRERESEREREBERERAPERAPVQ4RF9QC/iaBAQEjWfQNb6GSMG3fIG6SMG2d0PQEgQEB1wBZbBJvAuIgbuMAIG7y0IBvIoEBC1ADf3EhbpVbWfRZMJjIAc8AQTP0QeKBAQECyFkC9ACBAQHPAMkQNxIgbpUwWfRaMJRBM/QV4gRWFFYUVhRWFFYUVhRWFFYUVhRWFFYUVhTZ1QL4VhRWFFYUVhRWFFYUVhRWFFYUERQRKREUERMRKBETERIRJxESERERJhERERARJREQDxEkDw4RIw4NESINDBEhDAsRIAsKER8KCREeCQgRHQgHERwHBhEbBgURGgUEERkEAxEYAwIRFwIBERYBERXbPFcQXw9sUREVERYRFdbXAESC8FJIIca2yaF+viaZY+A9GeQzaQ2YlQc6rUPMxrV04vGhAUgRFBEVERQRExEUERMREhETERIRERESEREREBERERAPERAPVQ7YAc4mgQEBI1n0DW+hkjBt3yBukjBtndD0BIEBAdcAWWwSbwLiIG7jACBu8tCAbyKBAQtQA39xIW6VW1n0WTCYyAHPAEEz9EHigQEBAshZAvQAgQEBzwDJEDcSIG6VMFn0WjCUQTP0FeIE2QL8MG2BAQsif3EhbpVbWfRZMJjIAc8AQTP0QeIRFBEXERQRExEWERMREhEVERIREREXEREREBEWERAPERUPDhEXDg0RFg0MERUMCxEXCwoRFgoJERUJCBEXCAcRFgcGERUGBREXBQQRFgQDERUDAhEXAgERFgERFds8AREWAW8C2tsARILwg11tyItwi8ZG1tuCyFPvQYL6u9So3lnCE/K1qzrn2b4A4IEBASEgbpIwbY4SIG7y0IBvIshZAvQAgQEBzwDJ4hAmVhkBIG6VMFn0WjCUQTP0FeIRFBEXERQRExEWERMREhEVERIREREUEREREBETERAPERIPDhERDg0REA0QzxC+EK0QnBCLEHoQaRBYBxA2RQQ='); + const __system = Cell.fromBase64('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'); let builder = beginCell(); builder.storeRef(__system); builder.storeUint(0, 1); @@ -1470,23 +1570,23 @@ const JettonLP_errors: { [key: number]: { message: string } } = { 135: { message: `Code of a contract was not found` }, 136: { message: `Invalid address` }, 137: { message: `Masterchain support is not enabled for this contract` }, - 1237: { message: `APY: rewards == 0` }, 2927: { message: `AccessControl: Role ID doesn't exist` }, 4429: { message: `Invalid sender` }, 5524: { message: `AccessControl: Role ADMIN is undefined` }, 6187: { message: `AccessControl: Doesn't have the CFO role` }, 7947: { message: `AccessControl: BadConfirmation` }, + 10852: { message: `Boost: no deposit to convert to rewards` }, 10858: { message: `AccessControl: Doesn't have the BRIDGE role` }, 11399: { message: `Insufficient LP balance to withdraw rewards` }, 12450: { message: `AccessControl: Role BRIDGE is undefined` }, - 12666: { message: `TokenBurnNotification: Amount exceeds underlying balance` }, - 14033: { message: `APY: totalSupply == 0` }, + 14981: { message: `LPWallet: Invalid sender` }, 15100: { message: `TokenBurn: Invalid balance` }, 17039: { message: `AccessControl: Doesn't have the ADMIN role` }, 17389: { message: `Deposit amount must be greater than zero.` }, - 18668: { message: `Can't Mint Anymore` }, + 18429: { message: `LPWallet: Insufficient gas` }, 21733: { message: `AccessControl: Role doesn't exist` }, - 23951: { message: `Insufficient gas` }, + 24034: { message: `LPWallet: Can't Mint Anymore` }, + 26241: { message: `TokenNotification: Unauthorised call` }, 26704: { message: `ReleaseTokens: Unauthorized release tokens call.` }, 29285: { message: `The caller has no staking position to withdraw` }, 29451: { message: `Protocol fee cannot exceed token fee.` }, @@ -1494,14 +1594,14 @@ const JettonLP_errors: { [key: number]: { message: string } } = { 33951: { message: `Protocol fee cannot exceed the token fee.` }, 34727: { message: `TokenBurnNotification: Missing staker position` }, 36999: { message: `Insufficient staker's balance to withdraw the amount.` }, + 38716: { message: `WithdrawProtocolFee: No protocol fee to withdraw` }, 40436: { message: `WithdrawGas: Insufficient TON balance` }, 41817: { message: `UpdateDeposit must originate from the LP wallet.` }, 42708: { message: `Invalid sender!` }, - 46518: { message: `APY: totalSupply and rewards are not on the same decimal scale` }, - 48807: { message: `TokenBurnNotification: Amount exceeds total supply` }, 50413: { message: `AccessControl: Doesnt have the role` }, 51942: { message: `Withdraw amount must be greater than zero.` }, 53581: { message: `AccessControl: Role CFO is undefined` }, + 59055: { message: `TokenTransfer: Insufficient TON value` }, 60960: { message: `TokenTransferInternal: Invalid balance` }, 61410: { message: `TokenTransfer: Invalid balance` }, } @@ -1526,8 +1626,10 @@ const JettonLP_types: ABIType[] = [ {"name":"JettonMint","header":2310479113,"fields":[{"name":"origin","type":{"kind":"simple","type":"address","optional":false}},{"name":"receiver","type":{"kind":"simple","type":"address","optional":false}},{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"custom_payload","type":{"kind":"simple","type":"cell","optional":true}},{"name":"forward_ton_amount","type":{"kind":"simple","type":"uint","optional":false,"format":"coins"}},{"name":"forward_payload","type":{"kind":"simple","type":"slice","optional":false,"format":"remainder"}}]}, {"name":"UpdateDeposits","header":3121058093,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"sender","type":{"kind":"simple","type":"address","optional":false}},{"name":"receiver","type":{"kind":"simple","type":"address","optional":false}}]}, {"name":"BridgeBoilerplate","header":null,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"payload","type":{"kind":"simple","type":"cell","optional":false}}]}, + {"name":"Boost","header":3863699873,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"InternalWithdrawDeposit","header":432565636,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"global_fee_growth","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"total_supply","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"InternalWithdrawFee","header":2441921564,"fields":[{"name":"lastFeeGrowth","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"owner","type":{"kind":"simple","type":"address","optional":false}},{"name":"balance","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, + {"name":"LPData","header":null,"fields":[{"name":"apy","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"available_underlying","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"decimals","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"fee_growth_global","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"fee_decimals","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"protocol_fee","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"protocol_fee_amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"token_fee","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"total_supply","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"ReleaseTokens","header":169475742,"fields":[{"name":"to","type":{"kind":"simple","type":"address","optional":false}},{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"body","type":{"kind":"simple","type":"cell","optional":true}}]}, {"name":"PoolPayload","header":null,"fields":[{"name":"mode","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"Position","header":null,"fields":[{"name":"balance","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"last_fee_growth","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"rewards","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, @@ -1543,6 +1645,7 @@ const JettonLP_types: ABIType[] = [ {"name":"WithdrawGas","header":602125092,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"WithdrawRewards","header":852627366,"fields":[]}, {"name":"WithdrawCallback","header":167527793,"fields":[{"name":"feeGrowthGlobal","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"rewards","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, + {"name":"WithdrawProtocolFee","header":3742263588,"fields":[]}, {"name":"WithdrawStake","header":1184505655,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"Staked","header":923309543,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"staker","type":{"kind":"simple","type":"address","optional":false}}]}, {"name":"LPTransfer","header":4122418836,"fields":[{"name":"amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"to","type":{"kind":"simple","type":"address","optional":false}}]}, @@ -1559,16 +1662,18 @@ const JettonLP_types: ABIType[] = [ {"name":"RevokeRole","header":1363080030,"fields":[{"name":"to","type":{"kind":"simple","type":"address","optional":false}},{"name":"role_id","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"RoleData","header":null,"fields":[{"name":"roles","type":{"kind":"dict","key":"address","value":"bool"}},{"name":"admin_role","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, {"name":"UpdateRoleAdmin","header":620382153,"fields":[{"name":"role_id","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"role_admin","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, - {"name":"JettonLP$Data","header":null,"fields":[{"name":"admin","type":{"kind":"simple","type":"address","optional":false}},{"name":"available_underlying","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"bridge","type":{"kind":"simple","type":"address","optional":false}},{"name":"cfo","type":{"kind":"simple","type":"address","optional":false}},{"name":"content","type":{"kind":"simple","type":"cell","optional":false}},{"name":"decimals","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"deployed","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"deposits","type":{"kind":"dict","key":"address","value":"Position","valueFormat":"ref"}},{"name":"fee_growth_global","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"gas_cost","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"query_id","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"mintable","type":{"kind":"simple","type":"bool","optional":false}},{"name":"owner","type":{"kind":"simple","type":"address","optional":false}},{"name":"protocolFee","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"protocol_fee_amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"roles","type":{"kind":"dict","key":"int","value":"RoleData","valueFormat":"ref"}},{"name":"stake_token","type":{"kind":"simple","type":"address","optional":false}},{"name":"tokenFee","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"token_wallet","type":{"kind":"simple","type":"address","optional":false}},{"name":"total_supply","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, + {"name":"JettonLP$Data","header":null,"fields":[{"name":"admin","type":{"kind":"simple","type":"address","optional":false}},{"name":"available_underlying","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"bridge","type":{"kind":"simple","type":"address","optional":false}},{"name":"boost_query_id","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"cfo","type":{"kind":"simple","type":"address","optional":false}},{"name":"content","type":{"kind":"simple","type":"cell","optional":false}},{"name":"decimals","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"deployed","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"deposits","type":{"kind":"dict","key":"address","value":"Position","valueFormat":"ref"}},{"name":"fee_growth_global","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"gas_cost","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"query_id","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"mintable","type":{"kind":"simple","type":"bool","optional":false}},{"name":"owner","type":{"kind":"simple","type":"address","optional":false}},{"name":"protocolFee","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"protocol_fee_amount","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"roles","type":{"kind":"dict","key":"int","value":"RoleData","valueFormat":"ref"}},{"name":"stake_token","type":{"kind":"simple","type":"address","optional":false}},{"name":"tokenFee","type":{"kind":"simple","type":"int","optional":false,"format":257}},{"name":"token_wallet","type":{"kind":"simple","type":"address","optional":false}},{"name":"total_supply","type":{"kind":"simple","type":"int","optional":false,"format":257}}]}, ] const JettonLP_getters: ABIGetter[] = [ + {"name":"underlying","arguments":[],"returnType":{"kind":"simple","type":"address","optional":false}}, {"name":"currentAPY","arguments":[],"returnType":{"kind":"simple","type":"int","optional":false,"format":257}}, {"name":"decimals","arguments":[],"returnType":{"kind":"simple","type":"int","optional":false,"format":257}}, {"name":"feeGrowthGlobal","arguments":[],"returnType":{"kind":"simple","type":"int","optional":false,"format":257}}, {"name":"get_admin","arguments":[],"returnType":{"kind":"simple","type":"address","optional":false}}, {"name":"get_available_underlying","arguments":[],"returnType":{"kind":"simple","type":"int","optional":false,"format":257}}, {"name":"get_cfo","arguments":[],"returnType":{"kind":"simple","type":"address","optional":false}}, + {"name":"get_data","arguments":[],"returnType":{"kind":"simple","type":"LPData","optional":false}}, {"name":"get_query_id","arguments":[],"returnType":{"kind":"simple","type":"int","optional":false,"format":257}}, {"name":"get_position","arguments":[{"name":"staker","type":{"kind":"simple","type":"address","optional":false}}],"returnType":{"kind":"simple","type":"Position","optional":false}}, {"name":"get_total_supply","arguments":[],"returnType":{"kind":"simple","type":"int","optional":false,"format":257}}, @@ -1588,12 +1693,14 @@ const JettonLP_getters: ABIGetter[] = [ ] export const JettonLP_getterMapping: { [key: string]: string } = { + 'underlying': 'getUnderlying', 'currentAPY': 'getCurrentApy', 'decimals': 'getDecimals', 'feeGrowthGlobal': 'getFeeGrowthGlobal', 'get_admin': 'getGetAdmin', 'get_available_underlying': 'getGetAvailableUnderlying', 'get_cfo': 'getGetCfo', + 'get_data': 'getGetData', 'get_query_id': 'getGetQueryId', 'get_position': 'getGetPosition', 'get_total_supply': 'getGetTotalSupply', @@ -1613,11 +1720,15 @@ export const JettonLP_getterMapping: { [key: string]: string } = { } const JettonLP_receivers: ABIReceiver[] = [ + {"receiver":"internal","message":{"kind":"empty"}}, + {"receiver":"internal","message":{"kind":"typed","type":"Boost"}}, {"receiver":"internal","message":{"kind":"typed","type":"WithdrawGas"}}, + {"receiver":"internal","message":{"kind":"typed","type":"WithdrawProtocolFee"}}, {"receiver":"internal","message":{"kind":"typed","type":"TokenNotification"}}, {"receiver":"internal","message":{"kind":"typed","type":"ReleaseTokens"}}, {"receiver":"internal","message":{"kind":"typed","type":"TokenBurnNotification"}}, {"receiver":"internal","message":{"kind":"typed","type":"WithdrawRewards"}}, + {"receiver":"internal","message":{"kind":"typed","type":"TokenExcesses"}}, {"receiver":"internal","message":{"kind":"typed","type":"UpdateDeposits"}}, {"receiver":"internal","message":{"kind":"typed","type":"Withdraw"}}, {"receiver":"internal","message":{"kind":"typed","type":"SetAdmin"}}, @@ -1627,7 +1738,6 @@ const JettonLP_receivers: ABIReceiver[] = [ {"receiver":"internal","message":{"kind":"typed","type":"UpdateFees"}}, {"receiver":"internal","message":{"kind":"typed","type":"UpdateGasCost"}}, {"receiver":"internal","message":{"kind":"typed","type":"Deploy"}}, - {"receiver":"internal","message":{"kind":"empty"}}, {"receiver":"internal","message":{"kind":"typed","type":"TokenUpdateContent"}}, {"receiver":"internal","message":{"kind":"typed","type":"ProvideWalletAddress"}}, {"receiver":"internal","message":{"kind":"typed","type":"GrantRole"}}, @@ -1666,12 +1776,21 @@ export class JettonLP implements Contract { this.init = init; } - async send(provider: ContractProvider, via: Sender, args: { value: bigint, bounce?: boolean| null | undefined }, message: WithdrawGas | TokenNotification | ReleaseTokens | TokenBurnNotification | WithdrawRewards | UpdateDeposits | Withdraw | SetAdmin | SetCFO | SetBridge | SetWalletAddress | UpdateFees | UpdateGasCost | Deploy | null | TokenUpdateContent | ProvideWalletAddress | GrantRole | RevokeRole | RenounceRole | UpdateRoleAdmin) { + async send(provider: ContractProvider, via: Sender, args: { value: bigint, bounce?: boolean| null | undefined }, message: null | Boost | WithdrawGas | WithdrawProtocolFee | TokenNotification | ReleaseTokens | TokenBurnNotification | WithdrawRewards | TokenExcesses | UpdateDeposits | Withdraw | SetAdmin | SetCFO | SetBridge | SetWalletAddress | UpdateFees | UpdateGasCost | Deploy | TokenUpdateContent | ProvideWalletAddress | GrantRole | RevokeRole | RenounceRole | UpdateRoleAdmin) { let body: Cell | null = null; + if (message === null) { + body = new Cell(); + } + if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'Boost') { + body = beginCell().store(storeBoost(message)).endCell(); + } if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'WithdrawGas') { body = beginCell().store(storeWithdrawGas(message)).endCell(); } + if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'WithdrawProtocolFee') { + body = beginCell().store(storeWithdrawProtocolFee()).endCell(); + } if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'TokenNotification') { body = beginCell().store(storeTokenNotification(message)).endCell(); } @@ -1684,6 +1803,9 @@ export class JettonLP implements Contract { if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'WithdrawRewards') { body = beginCell().store(storeWithdrawRewards()).endCell(); } + if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'TokenExcesses') { + body = beginCell().store(storeTokenExcesses(message)).endCell(); + } if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'UpdateDeposits') { body = beginCell().store(storeUpdateDeposits(message)).endCell(); } @@ -1711,9 +1833,6 @@ export class JettonLP implements Contract { if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'Deploy') { body = beginCell().store(storeDeploy(message)).endCell(); } - if (message === null) { - body = new Cell(); - } if (message && typeof message === 'object' && !(message instanceof Slice) && message.$$type === 'TokenUpdateContent') { body = beginCell().store(storeTokenUpdateContent(message)).endCell(); } @@ -1738,6 +1857,13 @@ export class JettonLP implements Contract { } + async getUnderlying(provider: ContractProvider) { + let builder = new TupleBuilder(); + let source = (await provider.get('underlying', builder.build())).stack; + let result = source.readAddress(); + return result; + } + async getCurrentApy(provider: ContractProvider) { let builder = new TupleBuilder(); let source = (await provider.get('currentAPY', builder.build())).stack; @@ -1780,6 +1906,13 @@ export class JettonLP implements Contract { return result; } + async getGetData(provider: ContractProvider) { + let builder = new TupleBuilder(); + let source = (await provider.get('get_data', builder.build())).stack; + const result = loadGetterTupleLPData(source); + return result; + } + async getGetQueryId(provider: ContractProvider) { let builder = new TupleBuilder(); let source = (await provider.get('get_query_id', builder.build())).stack;