@shapeshiftoss/unchained-client 10.14.11 → 10.15.0

package/dist/esm/tron/api.d.ts

@@ -3,10 +3,18 @@ export interface TronApiConfig {
     rpcUrl: string;
     apiKey?: string;
 }
+export type TronContractEnergyShare = {
+    callerPercent: number;
+    originEnergyLimit: number;
+    originEnergyAvailable: number;
+};
+export declare const getCallerEnergy: (energyUsed: number, share: TronContractEnergyShare) => number;
 export declare class TronApi {
     private readonly rpcUrl;
     private readonly apiKey;
     private tronWeb;
+    private readonly contracts;
+    private readonly originEnergy;
     private requestQueue;
     private readonly minRequestInterval;
     constructor(config: TronApiConfig);
@@ -24,10 +32,16 @@ export declare class TronApi {
             balance: string;
         }[];
     }>;
-    getTRC20Balance(params: {
+    getTrc20Balance(params: {
+        contractAddress: string;
         address: string;
+    }): Promise<string>;
+    getTrc20Allowance(params: {
         contractAddress: string;
+        owner: string;
+        spender: string;
     }): Promise<string>;
+    isAccountActivated(address: string): Promise<boolean>;
     getTxHistory(_params: {
         pubkey: string;
         pageSize?: number;
@@ -47,23 +61,29 @@ export declare class TronApi {
             hex: string;
         };
     }): Promise<string>;
-    private getChainPrices;
-    estimateFees(params: {
-        estimateFeesBody: {
-            serializedTx: string;
-        };
-    }): Promise<string>;
-    estimateTRC20TransferFee(params: {
+    getChainPrices(): Promise<{
+        bandwidthPrice: number;
+        energyPrice: number;
+        memoFee: number;
+    }>;
+    getContractEnergyShare(contractAddress: string): Promise<TronContractEnergyShare>;
+    private getContract;
+    private getPricingContext;
+    private getOriginEnergyAvailable;
+    private post;
+    estimateTrc20TransferFee(params: {
         contractAddress: string;
         from: string;
         to: string;
         amount: string;
+        requireEnergyShare?: boolean;
     }): Promise<string>;
-    getPriorityFees(): Promise<{
-        baseFee: string;
-        fast: string;
-        average: string;
-        slow: string;
-        estimatedBandwidth: string;
-    }>;
+    estimateContractCallFee(params: {
+        contractAddress: string;
+        from: string;
+        data: string;
+        callValue?: string;
+        requireEnergyShare?: boolean;
+    }): Promise<string>;
+    private getSimulatedEnergy;
 }

package/dist/esm/tron/api.js

@@ -1,8 +1,27 @@
 import { TronWeb } from 'tronweb';
+const TRON_CALLER_PAYS_ALL = {
+    callerPercent: 100,
+    originEnergyLimit: 0,
+    originEnergyAvailable: 0,
+};
+// java-tron reads a stored zero, which TronGrid omits, as this creator default
+const TRON_CREATOR_DEFAULT_ENERGY_LIMIT = 10_000_000;
+// A deployer's unspent energy moves slowly next to how often the swappers re-estimate
+const TRON_ORIGIN_ENERGY_TTL_MS = 15_000;
+// A deployer can raise the caller's share after deployment, so the split is re-read within the minute
+const TRON_CONTRACT_TTL_MS = 60_000;
+// The deployer covers the rest only out of what they have staked, so a dry deployer (Tether) leaves the caller paying in full
+export const getCallerEnergy = (energyUsed, share) => {
+    const originShare = Math.floor((energyUsed * (100 - share.callerPercent)) / 100);
+    const originCovered = Math.max(0, Math.min(originShare, share.originEnergyLimit, share.originEnergyAvailable));
+    return energyUsed - originCovered;
+};
 export class TronApi {
     rpcUrl;
     apiKey;
     tronWeb = null;
+    contracts = new Map();
+    originEnergy = new Map();
     requestQueue = Promise.resolve();
     minRequestInterval = 1_500;
     constructor(config) {
@@ -95,9 +114,12 @@ export class TronApi {
                     }
                     for (const contractAddress of Array.from(discoveredContracts).slice(0, MAX_FALLBACK_CONTRACTS)) {
                         await this.throttle();
-                        const balance = await this.getTRC20Balance({ address: params.pubkey, contractAddress });
-                        if (balance !== '0')
-                            tokens.push({ contractAddress, balance });
+                        await this.getTrc20Balance({ contractAddress, address: params.pubkey })
+                            .then(balance => {
+                            if (balance !== '0')
+                                tokens.push({ contractAddress, balance });
+                        })
+                            .catch(() => undefined);
                     }
                 }
                 catch (fallbackErr) {
@@ -118,16 +140,36 @@ export class TronApi {
             tokens,
         };
     }
-    async getTRC20Balance(params) {
-        try {
-            const tronWeb = await this.getTronWeb();
-            const contract = await tronWeb.contract().at(params.contractAddress);
-            const balance = await contract.balanceOf(params.address).call();
-            return balance.toString();
-        }
-        catch (_err) {
-            return '0';
-        }
+    async getTrc20Balance(params) {
+        const result = await this.getTronWeb().transactionBuilder.triggerConstantContract(params.contractAddress, 'balanceOf(address)', {}, [{ type: 'address', value: params.address }], params.address);
+        const [balance] = result.constant_result ?? [];
+        if (!balance)
+            throw new Error('[tron] balanceOf call returned no data');
+        return BigInt(`0x${balance}`).toString();
+    }
+    // A direct selector call - contract().at() would first fetch the ABI, doubling the requests
+    async getTrc20Allowance(params) {
+        const tronWeb = this.getTronWeb();
+        const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'allowance(address,address)', {}, [
+            { type: 'address', value: params.owner },
+            { type: 'address', value: params.spender },
+        ], params.owner);
+        const [allowance] = result.constant_result ?? [];
+        if (!allowance)
+            throw new Error('[tron] allowance call returned no data');
+        return BigInt(`0x${allowance}`).toString();
+    }
+    // Accounts exist on-chain only once they have received TRX; a fresh address returns {}
+    async isAccountActivated(address) {
+        const response = await fetch(`${this.rpcUrl}/wallet/getaccount`, {
+            method: 'POST',
+            headers: this.tronGridHeaders,
+            body: JSON.stringify({ address, visible: true }),
+        });
+        if (!response.ok)
+            throw new Error(`[tron] getaccount failed: ${response.status}`);
+        const data = await response.json();
+        return !!data.address;
     }
     getTxHistory(_params) {
         throw new Error('Transaction history is not supported for TRON');
@@ -146,13 +188,11 @@ export class TronApi {
                 body: JSON.stringify({ value: params.txid, visible: true }),
             }),
         ]);
-        if (!txResponse.ok) {
+        if (!txResponse.ok)
             return null;
-        }
         const tx = await txResponse.json();
-        if (!tx || !tx.txID) {
+        if (!tx || !tx.txID)
             return null;
-        }
         let blockNumber = 0;
         let blockTimeStamp = 0;
         let fee = '0';
@@ -186,9 +226,8 @@ export class TronApi {
             headers: this.tronGridHeaders,
             body: JSON.stringify({ num: params.height }),
         });
-        if (!response.ok) {
+        if (!response.ok)
             return null;
-        }
         return await response.json();
     }
     async sendTx(params) {
@@ -200,9 +239,8 @@ export class TronApi {
                 throw new Error(result.message || JSON.stringify(result) || 'Failed to broadcast transaction');
             }
             const txid = result.txid || result.transaction?.txID;
-            if (!txid) {
+            if (!txid)
                 throw new Error('Transaction ID not found in broadcast result');
-            }
             return txid;
         }
         catch (error) {
@@ -210,69 +248,138 @@ export class TronApi {
         }
     }
     async getChainPrices() {
-        try {
-            const tronWeb = await this.getTronWeb();
-            const params = await tronWeb.trx.getChainParameters();
-            const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
-            const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 420;
-            return { bandwidthPrice, energyPrice };
-        }
-        catch (_err) {
-            return { bandwidthPrice: 1000, energyPrice: 420 };
-        }
+        const params = await this.getTronWeb().trx.getChainParameters();
+        const param = (key) => {
+            const value = params.find(p => p.key === key)?.value;
+            if (value === undefined)
+                throw new Error(`[tron] chain parameter ${key} missing`);
+            return value;
+        };
+        return {
+            bandwidthPrice: param('getTransactionFee'),
+            energyPrice: param('getEnergyFee'),
+            memoFee: param('getMemoFee'),
+        };
     }
-    async estimateFees(params) {
-        try {
-            const { bandwidthPrice } = await this.getChainPrices();
-            const rawDataBytes = Buffer.from(params.estimateFeesBody.serializedTx, 'hex').length;
-            const signatureBytes = 65;
-            const totalBytes = rawDataBytes + signatureBytes;
-            const feeInSun = totalBytes * bandwidthPrice;
-            return String(feeInSun);
-        }
-        catch (err) {
-            throw new Error(`Failed to estimate fees: ${err}`);
-        }
+    // A plain address answers getcontract with {} and pays in full
+    async getContractEnergyShare(contractAddress) {
+        const contract = await this.getContract(contractAddress);
+        if (!contract.origin_address)
+            return TRON_CALLER_PAYS_ALL;
+        // TronGrid omits zero-valued fields, so a contract whose deployer pays everything carries no percent at all
+        const callerPercent = contract.consume_user_resource_percent ?? 0;
+        if (callerPercent >= 100)
+            return TRON_CALLER_PAYS_ALL;
+        return {
+            callerPercent,
+            originEnergyLimit: contract.origin_energy_limit || TRON_CREATOR_DEFAULT_ENERGY_LIMIT,
+            originEnergyAvailable: await this.getOriginEnergyAvailable(contract.origin_address),
+        };
     }
-    async estimateTRC20TransferFee(params) {
-        try {
-            const tronWeb = await this.getTronWeb();
-            const { energyPrice } = await this.getChainPrices();
-            const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'transfer(address,uint256)', {}, [
-                { type: 'address', value: params.to },
-                { type: 'uint256', value: params.amount },
-            ], params.from);
-            const energyUsed = result.energy_used ?? 0;
-            const feeInSun = energyUsed * energyPrice;
-            return String(feeInSun);
-        }
-        catch (_err) {
-            // Fallback: Worst case 130k energy at current 100 sun/energy
-            return '13000000'; // 13 TRX (more realistic than 31 TRX)
-        }
+    getContract(contractAddress) {
+        const cached = this.contracts.get(contractAddress);
+        if (cached && Date.now() - cached.readAt < TRON_CONTRACT_TTL_MS)
+            return cached.value;
+        const value = this.post('/wallet/getcontract', {
+            value: contractAddress,
+            visible: true,
+        })
+            .then(body => {
+            if (body.Error)
+                throw new Error(`[tron] getcontract failed: ${body.Error}`);
+            // only a contract record is worth keeping; an empty body is re-read next time
+            if (!body.origin_address && this.contracts.get(contractAddress)?.value === value) {
+                this.contracts.delete(contractAddress);
+            }
+            return body;
+        })
+            .catch(err => {
+            if (this.contracts.get(contractAddress)?.value === value) {
+                this.contracts.delete(contractAddress);
+            }
+            throw err;
+        });
+        this.contracts.set(contractAddress, { readAt: Date.now(), value });
+        return value;
     }
-    async getPriorityFees() {
-        try {
-            const { bandwidthPrice } = await this.getChainPrices();
-            const estimatedBytes = 268;
-            const baseFee = String(estimatedBytes * bandwidthPrice);
-            return {
-                baseFee,
-                fast: baseFee,
-                average: baseFee,
-                slow: baseFee,
-                estimatedBandwidth: String(estimatedBytes),
-            };
+    // A failed share lookup prices the simulation as if the caller paid in full, unless the caller must not guess
+    async getPricingContext(contractAddress, requireEnergyShare = false) {
+        const [{ energyPrice }, share] = await Promise.all([
+            this.getChainPrices(),
+            this.getContractEnergyShare(contractAddress).catch((error) => {
+                if (requireEnergyShare)
+                    throw error;
+                console.warn(`[tron] energy share lookup failed for ${contractAddress}, pricing in full`, error);
+                return TRON_CALLER_PAYS_ALL;
+            }),
+        ]);
+        return { energyPrice, share };
+    }
+    getOriginEnergyAvailable(originAddress) {
+        const cached = this.originEnergy.get(originAddress);
+        if (cached && Date.now() - cached.readAt < TRON_ORIGIN_ENERGY_TTL_MS)
+            return cached.value;
+        const value = this.post('/wallet/getaccountresource', { address: originAddress, visible: true })
+            .then(body => {
+            if (body.Error)
+                throw new Error(`[tron] getaccountresource failed: ${body.Error}`);
+            return Math.max(0, (body.EnergyLimit ?? 0) - (body.EnergyUsed ?? 0));
+        })
+            .catch(err => {
+            if (this.originEnergy.get(originAddress)?.value === value) {
+                this.originEnergy.delete(originAddress);
+            }
+            throw err;
+        });
+        this.originEnergy.set(originAddress, { readAt: Date.now(), value });
+        return value;
+    }
+    async post(path, body) {
+        const response = await fetch(`${this.rpcUrl}${path}`, {
+            method: 'POST',
+            headers: this.tronGridHeaders,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            throw new Error(`[tron] ${path} failed: ${response.status}`);
+        return response.json();
+    }
+    async estimateTrc20TransferFee(params) {
+        const tronWeb = this.getTronWeb();
+        const { energyPrice, share } = await this.getPricingContext(params.contractAddress, params.requireEnergyShare);
+        const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'transfer(address,uint256)', {}, [
+            { type: 'address', value: params.to },
+            { type: 'uint256', value: params.amount },
+        ], params.from);
+        const energy = this.getSimulatedEnergy(result, 'trc20 transfer');
+        return String(getCallerEnergy(energy, share) * energyPrice);
+    }
+    async estimateContractCallFee(params) {
+        const { energyPrice, share } = await this.getPricingContext(params.contractAddress, params.requireEnergyShare);
+        const response = await fetch(`${this.rpcUrl}/wallet/triggerconstantcontract`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.tronGridHeaders },
+            body: JSON.stringify({
+                owner_address: params.from,
+                contract_address: params.contractAddress,
+                data: params.data.startsWith('0x') ? params.data.slice(2) : params.data,
+                call_value: Number(params.callValue) || 0,
+                visible: true,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`[tron] contract call simulation request failed: ${response.status}`);
         }
-        catch (_err) {
-            const defaultFee = '268000';
-            return {
-                baseFee: defaultFee,
-                fast: defaultFee,
-                average: defaultFee,
-                slow: defaultFee,
-                estimatedBandwidth: '268',
-            };
+        const result = await response.json();
+        const energy = this.getSimulatedEnergy(result, 'contract call');
+        return String(getCallerEnergy(energy, share) * energyPrice);
+    }
+    // A revert still reports result.result: true with the partial energy burned - trusting it would underestimate
+    getSimulatedEnergy(result, label) {
+        const isReverted = result.transaction?.ret?.some(ret => ret.ret === 'FAILED');
+        if (result.result?.result !== true || isReverted || !result.energy_used) {
+            throw new Error(`[tron] ${label} simulation failed: ${result.result?.message ?? 'unknown error'}`);
         }
+        return result.energy_used;
     }
 }

package/dist/esm/tron/types.d.ts

@@ -29,6 +29,9 @@ export interface TronTx {
                     amount?: number;
                     owner_address?: string;
                     to_address?: string;
+                    contract_address?: string;
+                    call_value?: number;
+                    data?: string;
                 };
                 type_url: string;
             };
@@ -38,6 +41,7 @@ export interface TronTx {
         ref_block_hash: string;
         expiration: number;
         timestamp: number;
+        fee_limit?: number;
     };
     raw_data_hex: string;
     txID: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/unchained-client",
-  "version": "10.14.11",
+  "version": "10.15.0",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
   "type": "module",
@@ -27,11 +27,11 @@
     "bs58": "^5.0.0",
     "ethers": "6.11.1",
     "isomorphic-ws": "^4.0.1",
-    "viem": "2.43.5",
+    "viem": "2.55.11",
     "ws": "^8.17.1",
-    "@shapeshiftoss/caip": "^8.16.9",
-    "@shapeshiftoss/utils": "^1.1.0",
-    "@shapeshiftoss/contracts": "^1.0.7"
+    "@shapeshiftoss/caip": "^8.17.1",
+    "@shapeshiftoss/contracts": "^1.1.0",
+    "@shapeshiftoss/utils": "^1.3.1"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.5.1"

package/dist/cjs/generated/mayachain/models/AffiliateFee.d.ts

@@ -1,67 +0,0 @@
-/**
- * Mayachain Unchained API
- * Provides access to mayachain chain data.
- *
- * The version of the OpenAPI document: 1.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-/**
- *
- * @export
- * @interface AffiliateFee
- */
-export interface AffiliateFee {
-    /**
-     *
-     * @type {string}
-     * @memberof AffiliateFee
-     */
-    address?: string;
-    /**
-     *
-     * @type {string}
-     * @memberof AffiliateFee
-     */
-    amount?: string;
-    /**
-     *
-     * @type {string}
-     * @memberof AffiliateFee
-     */
-    asset?: string;
-    /**
-     *
-     * @type {string}
-     * @memberof AffiliateFee
-     */
-    blockHash?: string;
-    /**
-     *
-     * @type {number}
-     * @memberof AffiliateFee
-     */
-    blockHeight?: number;
-    /**
-     *
-     * @type {number}
-     * @memberof AffiliateFee
-     */
-    timestamp?: number;
-    /**
-     *
-     * @type {string}
-     * @memberof AffiliateFee
-     */
-    txId?: string;
-}
-/**
- * Check if a given object implements the AffiliateFee interface.
- */
-export declare function instanceOfAffiliateFee(value: object): boolean;
-export declare function AffiliateFeeFromJSON(json: any): AffiliateFee;
-export declare function AffiliateFeeFromJSONTyped(json: any, ignoreDiscriminator: boolean): AffiliateFee;
-export declare function AffiliateFeeToJSON(value?: AffiliateFee | null): any;

package/dist/cjs/generated/mayachain/models/AffiliateFee.js

@@ -1,63 +0,0 @@
-"use strict";
-// @ts-nocheck
-/* tslint:disable */
-/* eslint-disable */
-/**
- * Mayachain Unchained API
- * Provides access to mayachain chain data.
- *
- * The version of the OpenAPI document: 1.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AffiliateFeeToJSON = exports.AffiliateFeeFromJSONTyped = exports.AffiliateFeeFromJSON = exports.instanceOfAffiliateFee = void 0;
-const runtime_1 = require("../runtime");
-/**
- * Check if a given object implements the AffiliateFee interface.
- */
-function instanceOfAffiliateFee(value) {
-    let isInstance = true;
-    return isInstance;
-}
-exports.instanceOfAffiliateFee = instanceOfAffiliateFee;
-function AffiliateFeeFromJSON(json) {
-    return AffiliateFeeFromJSONTyped(json, false);
-}
-exports.AffiliateFeeFromJSON = AffiliateFeeFromJSON;
-function AffiliateFeeFromJSONTyped(json, ignoreDiscriminator) {
-    if ((json === undefined) || (json === null)) {
-        return json;
-    }
-    return {
-        'address': !(0, runtime_1.exists)(json, 'address') ? undefined : json['address'],
-        'amount': !(0, runtime_1.exists)(json, 'amount') ? undefined : json['amount'],
-        'asset': !(0, runtime_1.exists)(json, 'asset') ? undefined : json['asset'],
-        'blockHash': !(0, runtime_1.exists)(json, 'blockHash') ? undefined : json['blockHash'],
-        'blockHeight': !(0, runtime_1.exists)(json, 'blockHeight') ? undefined : json['blockHeight'],
-        'timestamp': !(0, runtime_1.exists)(json, 'timestamp') ? undefined : json['timestamp'],
-        'txId': !(0, runtime_1.exists)(json, 'txId') ? undefined : json['txId'],
-    };
-}
-exports.AffiliateFeeFromJSONTyped = AffiliateFeeFromJSONTyped;
-function AffiliateFeeToJSON(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value === null) {
-        return null;
-    }
-    return {
-        'address': value.address,
-        'amount': value.amount,
-        'asset': value.asset,
-        'blockHash': value.blockHash,
-        'blockHeight': value.blockHeight,
-        'timestamp': value.timestamp,
-        'txId': value.txId,
-    };
-}
-exports.AffiliateFeeToJSON = AffiliateFeeToJSON;

package/dist/cjs/generated/mayachain/models/AffiliateFees.d.ts

@@ -1,32 +0,0 @@
-/**
- * Mayachain Unchained API
- * Provides access to mayachain chain data.
- *
- * The version of the OpenAPI document: 1.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-import type { AffiliateFee } from './AffiliateFee';
-/**
- * Contains info about affiliate fee history
- * @export
- * @interface AffiliateFees
- */
-export interface AffiliateFees {
-    /**
-     * Affiliate fees
-     * @type {Array<AffiliateFee>}
-     * @memberof AffiliateFees
-     */
-    fees: Array<AffiliateFee>;
-}
-/**
- * Check if a given object implements the AffiliateFees interface.
- */
-export declare function instanceOfAffiliateFees(value: object): boolean;
-export declare function AffiliateFeesFromJSON(json: any): AffiliateFees;
-export declare function AffiliateFeesFromJSONTyped(json: any, ignoreDiscriminator: boolean): AffiliateFees;
-export declare function AffiliateFeesToJSON(value?: AffiliateFees | null): any;

package/dist/cjs/generated/mayachain/models/AffiliateFees.js

@@ -1,52 +0,0 @@
-"use strict";
-// @ts-nocheck
-/* tslint:disable */
-/* eslint-disable */
-/**
- * Mayachain Unchained API
- * Provides access to mayachain chain data.
- *
- * The version of the OpenAPI document: 1.0.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AffiliateFeesToJSON = exports.AffiliateFeesFromJSONTyped = exports.AffiliateFeesFromJSON = exports.instanceOfAffiliateFees = void 0;
-const AffiliateFee_1 = require("./AffiliateFee");
-/**
- * Check if a given object implements the AffiliateFees interface.
- */
-function instanceOfAffiliateFees(value) {
-    let isInstance = true;
-    isInstance = isInstance && "fees" in value;
-    return isInstance;
-}
-exports.instanceOfAffiliateFees = instanceOfAffiliateFees;
-function AffiliateFeesFromJSON(json) {
-    return AffiliateFeesFromJSONTyped(json, false);
-}
-exports.AffiliateFeesFromJSON = AffiliateFeesFromJSON;
-function AffiliateFeesFromJSONTyped(json, ignoreDiscriminator) {
-    if ((json === undefined) || (json === null)) {
-        return json;
-    }
-    return {
-        'fees': (json['fees'].map(AffiliateFee_1.AffiliateFeeFromJSON)),
-    };
-}
-exports.AffiliateFeesFromJSONTyped = AffiliateFeesFromJSONTyped;
-function AffiliateFeesToJSON(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value === null) {
-        return null;
-    }
-    return {
-        'fees': (value.fees.map(AffiliateFee_1.AffiliateFeeToJSON)),
-    };
-}
-exports.AffiliateFeesToJSON = AffiliateFeesToJSON;