code: async def create_payment_address(wallet_handle: int,
                                   payment_method: str,
                                   config: str) -> str:
      
  
      logger = logging.getLogger(__name__)
      logger.debug("create_payment_address: >>> wallet_handle: %r, payment_method: %r, config: %r",
                   wallet_handle,
                   payment_method,
                   config)
  
      if not hasattr(create_payment_address, "cb"):
          logger.debug("create_payment_address: Creating callback")
          create_payment_address.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p))
  
      c_wallet_handle = c_int32(wallet_handle)
      c_payment_method = c_char_p(payment_method.encode('utf-8'))
      config = c_char_p(config.encode('utf-8'))
  
      request_result = await do_call('indy_create_payment_address',
                                     c_wallet_handle,
                                     c_payment_method,
                                     config,
                                     create_payment_address.cb)
  
      res = request_result.decode()
      logger.debug("create_payment_address: <<< res: %r", res)
      return res
docs: Create the payment address for specified payment method
  
  
       This method generates private part of payment address
       and stores it in a secure place. Ideally it should be
       secret in libindy wallet (see crypto module).
  
       Note that payment method should be able to resolve this
       secret by fully resolvable payment address format.
  
      :param wallet_handle: wallet handle (created by open_wallet).
      :param payment_method: Payment method to use (for example, 'sov').
      :param config: payment address config as json:
         {
           seed: <str>, // allows deterministic creation of payment address
         }
      :return: payment_address: public identifier of payment address in fully resolvable payment address format.