feat: Add IBCv2 timeout entrypoint

Author: kulikthebird

internal/api/bindings.h

@@ -215,6 +215,11 @@ typedef struct AnalysisReport {
    * This does not guarantee they are functional or even have the correct signatures.
    */
   bool has_ibc_entry_points;
+  /**
+   * `true` if and only if all required ibc2 exports exist as exported functions.
+   * This does not guarantee they are functional or even have the correct signatures.
+   */
+  bool has_ibc2_entry_points;
   /**
    * A UTF-8 encoded comma separated list of all entrypoints that
    * are exported by the contract.
@@ -645,6 +650,18 @@ struct UnmanagedVector ibc2_packet_receive(struct cache_t *cache,
                                            struct GasReport *gas_report,
                                            struct UnmanagedVector *error_msg);
 
+struct UnmanagedVector ibc2_packet_timeout(struct cache_t *cache,
+                                           struct ByteSliceView checksum,
+                                           struct ByteSliceView env,
+                                           struct ByteSliceView msg,
+                                           struct Db db,
+                                           struct GoApi api,
+                                           struct GoQuerier querier,
+                                           uint64_t gas_limit,
+                                           bool print_debug,
+                                           struct GasReport *gas_report,
+                                           struct UnmanagedVector *error_msg);
+
 struct UnmanagedVector new_unmanaged_vector(bool nil, const uint8_t *ptr, uintptr_t length);
 
 void destroy_unmanaged_vector(struct UnmanagedVector v);

internal/api/lib.go

@@ -10,7 +10,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"strings"
 	"syscall"
 
@@ -164,11 +163,10 @@ func AnalyzeCode(cache Cache, checksum []byte) (*types.AnalysisReport, error) {
 	requiredCapabilities := string(copyAndDestroyUnmanagedVector(report.required_capabilities))
 	entrypoints := string(copyAndDestroyUnmanagedVector(report.entrypoints))
 	entrypoints_array := strings.Split(entrypoints, ",")
-	hasIBC2EntryPoints := slices.Contains(entrypoints_array, "ibc2_packet_receive")
 
 	res := types.AnalysisReport{
 		HasIBCEntryPoints:      bool(report.has_ibc_entry_points),
-		HasIBC2EntryPoints:     hasIBC2EntryPoints,
+		HasIBC2EntryPoints:     bool(report.has_ibc2_entry_points),
 		RequiredCapabilities:   requiredCapabilities,
 		Entrypoints:            entrypoints_array,
 		ContractMigrateVersion: optionalU64ToPtr(report.contract_migrate_version),
@@ -723,6 +721,48 @@ func IBC2PacketReceive(
 	return copyAndDestroyUnmanagedVector(res), convertGasReport(gasReport), nil
 }
 
+func IBC2PacketTimeout(
+	cache Cache,
+	checksum []byte,
+	env []byte,
+	payload []byte,
+	gasMeter *types.GasMeter,
+	store types.KVStore,
+	api *types.GoAPI,
+	querier *Querier,
+	gasLimit uint64,
+	printDebug bool,
+) ([]byte, types.GasReport, error) {
+	cs := makeView(checksum)
+	defer runtime.KeepAlive(checksum)
+	e := makeView(env)
+	defer runtime.KeepAlive(env)
+	pa := makeView(payload)
+	defer runtime.KeepAlive(payload)
+	var pinner runtime.Pinner
+	pinner.Pin(gasMeter)
+	checkAndPinAPI(api, pinner)
+	checkAndPinQuerier(querier, pinner)
+	defer pinner.Unpin()
+
+	callID := startCall()
+	defer endCall(callID)
+
+	dbState := buildDBState(store, callID)
+	db := buildDB(&dbState, gasMeter)
+	a := buildAPI(api)
+	q := buildQuerier(querier)
+	var gasReport C.GasReport
+	errmsg := uninitializedUnmanagedVector()
+
+	res, err := C.ibc2_packet_timeout(cache.ptr, cs, e, pa, db, a, q, cu64(gasLimit), cbool(printDebug), &gasReport, &errmsg)
+	if err != nil && err.(syscall.Errno) != C.ErrnoValue_Success {
+		// Depending on the nature of the error, `gasUsed` will either have a meaningful value, or just 0.
+		return nil, convertGasReport(gasReport), errorWithMessage(err, errmsg)
+	}
+	return copyAndDestroyUnmanagedVector(res), convertGasReport(gasReport), nil
+}
+
 func IBCPacketAck(
 	cache Cache,
 	checksum []byte,

lib_libwasmvm.go

@@ -712,6 +712,41 @@ func (vm *VM) IBC2PacketReceive(
 	return &result, gasReport.UsedInternally, nil
 }
 
+// IBC2PacketTimeout is available on IBCv2-enabled contracts and is called when an
+// outgoing packet (previously sent by this contract) will provably never be executed.
+// Usually handled like ack returning an error
+func (vm *VM) IBC2PacketTimeout(
+	checksum Checksum,
+	env types.Env,
+	msg types.IBC2PacketTimeoutMsg,
+	store KVStore,
+	goapi GoAPI,
+	querier Querier,
+	gasMeter GasMeter,
+	gasLimit uint64,
+	deserCost types.UFraction,
+) (*types.IBCBasicResult, uint64, error) {
+	envBin, err := json.Marshal(env)
+	if err != nil {
+		return nil, 0, err
+	}
+	msgBin, err := json.Marshal(msg)
+	if err != nil {
+		return nil, 0, err
+	}
+	data, gasReport, err := api.IBC2PacketTimeout(vm.cache, checksum, envBin, msgBin, &gasMeter, store, &goapi, &querier, gasLimit, vm.printDebug)
+	if err != nil {
+		return nil, gasReport.UsedInternally, err
+	}
+
+	var result types.IBCBasicResult
+	err = DeserializeResponse(gasLimit, deserCost, &gasReport, data, &result)
+	if err != nil {
+		return nil, gasReport.UsedInternally, err
+	}
+	return &result, gasReport.UsedInternally, nil
+}
+
 func compileCost(code WasmCode) uint64 {
 	// CostPerByte is how much CosmWasm gas is charged *per byte* for compiling WASM code.
 	// Benchmarks and numbers (in SDK Gas) were discussed in: