// SendPacket is called by a module in order to send an IBC packet on a channel.
// The packet sequence generated for the packet to be sent is returned. An error
// is returned if one occurs.
func (k Keeper) SendPacket(
	ctx sdk.Context,
	channelCap *capabilitytypes.Capability,
	sourcePort string,
	sourceChannel string,
	timeoutHeight clienttypes.Height,
	timeoutTimestamp uint64,
	data []byte,
) (uint64, error) {

  	// ...

	// check if packet is timed out on the receiving chain
	timeout := types.NewTimeout(packet.GetTimeoutHeight().(clienttypes.Height), packet.GetTimeoutTimestamp())
	if timeout.Elapsed(latestHeight.(clienttypes.Height), latestTimestamp) {
		return 0, errorsmod.Wrap(timeout.ErrTimeoutElapsed(latestHeight.(clienttypes.Height), latestTimestamp), "invalid packet timeout")
	}

	commitment := types.CommitPacket(k.cdc, packet)

	k.SetNextSequenceSend(ctx, sourcePort, sourceChannel, sequence+1)
	k.SetPacketCommitment(ctx, sourcePort, sourceChannel, packet.GetSequence(), commitment)

	emitSendPacketEvent(ctx, packet, channel, timeoutHeight)

	return packet.GetSequence(), nil
}

// Elapsed returns true if either the provided height or timestamp is past the
// respective absolute timeout values.
func (t Timeout) Elapsed(height clienttypes.Height, timestamp uint64) bool {
	return t.heightElapsed(height) || t.timestampElapsed(timestamp)
}

// heightElapsed returns true if the timeout height is non empty
// and the timeout height is greater than or equal to the relative height.
func (t Timeout) heightElapsed(height clienttypes.Height) bool {
	return !t.Height.IsZero() && height.GTE(t.Height)
}

// Compare implements a method to compare two heights. When comparing two heights a, b
// we can call a.Compare(b) which will return
// -1 if a < b
// 0  if a = b
// 1  if a > b
//
// It first compares based on revision numbers, whichever has the higher revision number is the higher height
// If revision number is the same, then the revision height is compared
func (h Height) Compare(other exported.Height) int64 {
	height, ok := other.(Height)
	if !ok {
		panic(fmt.Errorf("cannot compare against invalid height type: %T. expected height type: %T", other, h))
	}
	var a, b big.Int
	if h.RevisionNumber != height.RevisionNumber {
		a.SetUint64(h.RevisionNumber)
		b.SetUint64(height.RevisionNumber)
	} else {
		a.SetUint64(h.RevisionHeight)
		b.SetUint64(height.RevisionHeight)
	}
	return int64(a.Cmp(&b))
}

// GTE Helper comparison function returns true if h >= other
func (h Height) GTE(other exported.Height) bool {
	cmp := h.Compare(other)
	return cmp >= 0
}

  simd tx ibc-transfer transfer [src-port] [src-channel] [receiver] [amount] [chain-id]

  docker exec -it simapp-1 simd tx ibc-transfer transfer transfer channel-0 cosmos1zaavvzxez0elundtn32qnk9lkm8kmcszzsv80v 100alice --from validator --chain-id alice --packet-timeout-height 9000-9100 --packet-timeout-timestamp 0 --gas-prices 0.01alice --keyring-backend test --yes

  10:18AM ERR failure when running app err="relative timeouts using block height is not supported"

  simd tx ibc-transfer transfer [src-port] [src-channel] [receiver] [amount] [chain-id]

func NewTransferTxCmd() *cobra.Command {
	cmd := &cobra.Command{
        // ...
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientTxContext(cmd)
			if err != nil {
				return err
			}

            //...

			timeoutHeightStr, err := cmd.Flags().GetString(flagPacketTimeoutHeight)
			if err != nil {
				return err
			}

			timeoutHeight, err := clienttypes.ParseHeight(timeoutHeightStr)
			if err != nil {
				return err
			}

			timeoutTimestamp, err := cmd.Flags().GetUint64(flagPacketTimeoutTimestamp)
			if err != nil {
				return err
			}

			absoluteTimeouts, err := cmd.Flags().GetBool(flagAbsoluteTimeouts)
			if err != nil {
				return err
			}

			memo, err := cmd.Flags().GetString(flagMemo)
			if err != nil {
				return err
			}

			// NOTE: relative timeouts using block height are not supported.
			// if the timeouts are not absolute, CLI users rely solely on local clock time in order to calculate relative timestamps.
			if !absoluteTimeouts {
				if !timeoutHeight.IsZero() {
					return errors.New("relative timeouts using block height is not supported")
				}

				if timeoutTimestamp == 0 {
					return errors.New("relative timeouts must provide a non zero value timestamp")
				}

				// use local clock time as reference time for calculating timeout timestamp.
				now := time.Now().UnixNano()
				if now <= 0 {
					return errors.New("local clock time is not greater than Jan 1st, 1970 12:00 AM")
				}

				timeoutTimestamp = uint64(now) + timeoutTimestamp
			}

			msg := types.NewMsgTransfer(
				srcPort, srcChannel, coin, sender, receiver, timeoutHeight, timeoutTimestamp, memo,
			)

			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
		},
	}

	cmd.Flags().String(flagPacketTimeoutHeight, "0-0", "Packet timeout block height in the format {revision}-{height}.")
	cmd.Flags().Uint64(flagPacketTimeoutTimestamp, defaultRelativePacketTimeoutTimestamp, "Packet timeout timestamp in nanoseconds from now. Default is 10 minutes. On IBC v1 protocol, either timeout timestamp or timeout height must be set. On IBC v2 protocol timeout timestamp must be set.")
	cmd.Flags().Bool(flagAbsoluteTimeouts, false, "Timeout flags are used as absolute timeouts.")
	cmd.Flags().String(flagMemo, "", "Memo to be sent along with the packet.")

	flags.AddTxFlagsToCmd(cmd)

	return cmd
}

  docker exec -it simapp-1 simd tx ibc-transfer transfer transfer channel-0 cosmos1zaavvzxez0elundtn32qnk9lkm8kmcszzsv80v 100alice --from validator --chain-id alice --packet-timeout-height 9000-9100 --packet-timeout-timestamp 0 --gas-prices 0.01alice --keyring-backend test --yes
  code: 0
  codespace: ""
  data: ""
  events: []
  gas_used: "0"
  gas_wanted: "0"
  height: "0"
  info: ""
  logs: []
  raw_log: ""
  timestamp: ""
  tx: null
  txhash: 83FB666C3789AD0AB710A2B47A7DCC73BA2D463AA00114B354CEE76FA7A3E274

{
  "type": "send_packet",
  "attributes": [
    {
      "key": "packet_data",
      "value": "{\"amount\":\"100\",\"denom\":\"alice\",\"receiver\":\"cosmos1zaavvzxez0elundtn32qnk9lkm8kmcszzsv80v\",\"sender\":\"cosmos1zaavvzxez0elundtn32qnk9lkm8kmcszzsv80v\"}",
      "index": true
    },
    {
      "key": "packet_data_hex",
      "value": "7b22616d6f756e74223a22313030222c2264656e6f6d223a22616c696365222c227265636569766572223a22636f736d6f73317a616176767a78657a30656c756e64746e3332716e6b396c6b6d386b6d63737a7a7376383076222c2273656e646572223a22636f736d6f73317a616176767a78657a30656c756e64746e3332716e6b396c6b6d386b6d63737a7a7376383076227d",
      "index": true
    },
    {
      "key": "packet_timeout_height",
      "value": "9001-9135",
      "index": true
    },
    {
      "key": "packet_timeout_timestamp",
      "value": "0",
      "index": true
    },
    {
      "key": "packet_sequence",
      "value": "1",
      "index": true
    },
    {
      "key": "packet_src_port",
      "value": "transfer",
      "index": true
    },
    {
      "key": "packet_src_channel",
      "value": "channel-0",
      "index": true
    },
    {
      "key": "packet_dst_port",
      "value": "transfer",
      "index": true
    },
    {
      "key": "packet_dst_channel",
      "value": "channel-0",
      "index": true
    },
    {
      "key": "packet_channel_ordering",
      "value": "ORDER_UNORDERED",
      "index": true
    },
    {
      "key": "packet_connection",
      "value": "connection-0",
      "index": true
    },
    {
      "key": "connection_id",
      "value": "connection-0",
      "index": true
    },
    {
      "key": "msg_index",
      "value": "0",
      "index": true
    }
  ]
}

func NewTransferTxCmd() *cobra.Command {
	cmd := &cobra.Command{
        // ...
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientTxContext(cmd)
			if err != nil {
				return err
			}
        // ...
			timeoutHeightStr, err := cmd.Flags().GetString(flagPacketTimeoutHeight)
			if err != nil {
				return err
			}
			timeoutHeight, err := clienttypes.ParseHeight(timeoutHeightStr)
			if err != nil {
				return err
			}

			timeoutTimestamp, err := cmd.Flags().GetUint64(flagPacketTimeoutTimestamp)
			if err != nil {
				return err
			}

			absoluteTimeouts, err := cmd.Flags().GetBool(flagAbsoluteTimeouts)
			if err != nil {
				return err
			}

			memo, err := cmd.Flags().GetString(flagMemo)
			if err != nil {
				return err
			}

			// if the timeouts are not absolute, retrieve latest block height and block timestamp
			// for the consensus state connected to the destination port/channel.
			// localhost clients must rely solely on local clock time in order to use relative timestamps.
			if !absoluteTimeouts {
				clientRes, err := channelutils.QueryChannelClientState(clientCtx, srcPort, srcChannel, false)
				if err != nil {
					return err
				}

				var clientState exported.ClientState
				if err := clientCtx.InterfaceRegistry.UnpackAny(clientRes.IdentifiedClientState.ClientState, &clientState); err != nil {
					return err
				}

				clientHeight, ok := clientState.GetLatestHeight().(clienttypes.Height)
				if !ok {
					return fmt.Errorf("invalid height type. expected type: %T, got: %T", clienttypes.Height{}, clientState.GetLatestHeight())
				}

				var consensusState exported.ConsensusState
				if clientState.ClientType() != exported.Localhost {
					consensusStateRes, err := clientutils.QueryConsensusState(clientCtx, clientRes.IdentifiedClientState.ClientId, clientHeight, false, true)
					if err != nil {
						return err
					}

					if err := clientCtx.InterfaceRegistry.UnpackAny(consensusStateRes.ConsensusState, &consensusState); err != nil {
						return err
					}
				}

				if !timeoutHeight.IsZero() {
					absoluteHeight := clientHeight
					absoluteHeight.RevisionNumber += timeoutHeight.RevisionNumber
					absoluteHeight.RevisionHeight += timeoutHeight.RevisionHeight
					timeoutHeight = absoluteHeight
				}

				// use local clock time as reference time if it is later than the
				// consensus state timestamp of the counterparty chain, otherwise
				// still use consensus state timestamp as reference.
				// for localhost clients local clock time is always used.
				if timeoutTimestamp != 0 {
					var consensusStateTimestamp uint64
					if consensusState != nil {
						consensusStateTimestamp = consensusState.GetTimestamp()
					}

					now := time.Now().UnixNano()
					if now > 0 {
						now := uint64(now)
						if now > consensusStateTimestamp {
							timeoutTimestamp = now + timeoutTimestamp
						} else {
							timeoutTimestamp = consensusStateTimestamp + timeoutTimestamp
						}
					} else {
						return errors.New("local clock time is not greater than Jan 1st, 1970 12:00 AM")
					}
				}
			}

			msg := types.NewMsgTransfer(
				srcPort, srcChannel, coin, sender, receiver, timeoutHeight, timeoutTimestamp, memo,
			)
			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
		},
	}

	cmd.Flags().String(flagPacketTimeoutHeight, types.DefaultRelativePacketTimeoutHeight, "Packet timeout block height. The timeout is disabled when set to 0-0.")
	cmd.Flags().Uint64(flagPacketTimeoutTimestamp, types.DefaultRelativePacketTimeoutTimestamp, "Packet timeout timestamp in nanoseconds from now. Default is 10 minutes. The timeout is disabled when set to 0.")
	cmd.Flags().Bool(flagAbsoluteTimeouts, false, "Timeout flags are used as absolute timeouts.")
	cmd.Flags().String(flagMemo, "", "Memo to be sent along with the packet.")
	flags.AddTxFlagsToCmd(cmd)

	return cmd
}