@block52/poker-vm-sdk 1.1.11 → 1.1.12

package/dist/index.d.ts

@@ -46461,6 +46461,37 @@ declare class SigningCosmosClient extends CosmosClient {
      * Get the current wallet
      */
     getWallet(): DirectSecp256k1HdWallet | undefined;
+    /**
+     * Register an NFT as the player's avatar
+     *
+     * This broadcasts a MsgRegisterNftAvatar transaction containing:
+     * - The ETH address that owns the NFT
+     * - The NFT contract address and token ID
+     * - An ETH signature proving the ETH address owner authorizes this cosmos address
+     *   to use the NFT as their avatar
+     *
+     * The validator verifies the ETH signature via ecrecover and, if valid,
+     * stores the mapping on-chain: cosmosAddress → (contractAddress, tokenId)
+     *
+     * @param ethAddress - The ETH address that owns the NFT
+     * @param contractAddress - The NFT contract address on Ethereum/Base
+     * @param tokenId - The NFT token ID
+     * @param ethSignature - EIP-191 signature proving ETH address ownership
+     * @returns Transaction hash
+     */
+    registerNftAvatar(ethAddress: string, contractAddress: string, tokenId: string, ethSignature: string): Promise<string>;
+    /**
+     * Query a registered NFT avatar for a cosmos address
+     *
+     * @param cosmosAddress - The cosmos address to look up
+     * @returns The NFT avatar data if registered, or null if not found
+     */
+    queryNftAvatar(cosmosAddress: string): Promise<{
+        cosmosAddress: string;
+        ethAddress: string;
+        contractAddress: string;
+        tokenId: string;
+    } | null>;
 }
 /**
  * Create a signing client from a mnemonic

package/dist/index.esm.js

@@ -4167,6 +4167,119 @@ const MsgDeleteGame = {
         return message;
     },
 };
+function createBaseMsgRegisterNftAvatar() {
+    return { creator: "", ethAddress: "", contractAddress: "", tokenId: "", ethSignature: "" };
+}
+const MsgRegisterNftAvatar = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.ethAddress !== "") {
+            writer.uint32(18).string(message.ethAddress);
+        }
+        if (message.contractAddress !== "") {
+            writer.uint32(26).string(message.contractAddress);
+        }
+        if (message.tokenId !== "") {
+            writer.uint32(34).string(message.tokenId);
+        }
+        if (message.ethSignature !== "") {
+            writer.uint32(42).string(message.ethSignature);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRegisterNftAvatar();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.creator = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ethAddress = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.contractAddress = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.tokenId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.ethSignature = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            creator: isSet$2b(object.creator) ? globalThis.String(object.creator) : "",
+            ethAddress: isSet$2b(object.ethAddress) ? globalThis.String(object.ethAddress) : "",
+            contractAddress: isSet$2b(object.contractAddress) ? globalThis.String(object.contractAddress) : "",
+            tokenId: isSet$2b(object.tokenId) ? globalThis.String(object.tokenId) : "",
+            ethSignature: isSet$2b(object.ethSignature) ? globalThis.String(object.ethSignature) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.creator !== "") {
+            obj.creator = message.creator;
+        }
+        if (message.ethAddress !== "") {
+            obj.ethAddress = message.ethAddress;
+        }
+        if (message.contractAddress !== "") {
+            obj.contractAddress = message.contractAddress;
+        }
+        if (message.tokenId !== "") {
+            obj.tokenId = message.tokenId;
+        }
+        if (message.ethSignature !== "") {
+            obj.ethSignature = message.ethSignature;
+        }
+        return obj;
+    },
+    create(base) {
+        return MsgRegisterNftAvatar.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRegisterNftAvatar();
+        message.creator = object.creator ?? "";
+        message.ethAddress = object.ethAddress ?? "";
+        message.contractAddress = object.contractAddress ?? "";
+        message.tokenId = object.tokenId ?? "";
+        message.ethSignature = object.ethSignature ?? "";
+        return message;
+    },
+};
 function isSet$2b(value) {
     return value !== null && value !== undefined;
 }
@@ -4187,6 +4300,7 @@ const msgTypes$u = [
     ["/pokerchain.poker.v1.MsgUpdateEthBlockHeight", MsgUpdateEthBlockHeight],
     ["/pokerchain.poker.v1.MsgTopUp", MsgTopUp],
     ["/pokerchain.poker.v1.MsgDeleteGame", MsgDeleteGame],
+    ["/pokerchain.poker.v1.MsgRegisterNftAvatar", MsgRegisterNftAvatar],
 ];
 
 /**
@@ -58148,6 +58262,93 @@ class SigningCosmosClient extends CosmosClient {
     getWallet() {
         return this.wallet;
     }
+    /**
+     * Register an NFT as the player's avatar
+     *
+     * This broadcasts a MsgRegisterNftAvatar transaction containing:
+     * - The ETH address that owns the NFT
+     * - The NFT contract address and token ID
+     * - An ETH signature proving the ETH address owner authorizes this cosmos address
+     *   to use the NFT as their avatar
+     *
+     * The validator verifies the ETH signature via ecrecover and, if valid,
+     * stores the mapping on-chain: cosmosAddress → (contractAddress, tokenId)
+     *
+     * @param ethAddress - The ETH address that owns the NFT
+     * @param contractAddress - The NFT contract address on Ethereum/Base
+     * @param tokenId - The NFT token ID
+     * @param ethSignature - EIP-191 signature proving ETH address ownership
+     * @returns Transaction hash
+     */
+    async registerNftAvatar(ethAddress, contractAddress, tokenId, ethSignature) {
+        await this.initializeSigningClient();
+        if (!this.signingClient || !this.wallet) {
+            throw new Error("Signing client not initialized");
+        }
+        const [account] = await this.wallet.getAccounts();
+        const creator = account.address;
+        // Create the message object
+        const msgRegisterNftAvatar = {
+            creator,
+            ethAddress,
+            contractAddress,
+            tokenId,
+            ethSignature
+        };
+        // Create the transaction message
+        const msg = {
+            typeUrl: "/pokerchain.poker.v1.MsgRegisterNftAvatar",
+            value: msgRegisterNftAvatar
+        };
+        const fee = gaslessFee();
+        const memo = "Register NFT avatar via SDK";
+        console.log("🖼️ Registering NFT avatar:", {
+            creator,
+            ethAddress,
+            contractAddress,
+            tokenId: tokenId.substring(0, 20) + (tokenId.length > 20 ? "..." : "")
+        });
+        try {
+            const result = await this.signingClient.signAndBroadcast(creator, [msg], fee, memo);
+            console.log("✅ NFT avatar registration successful:", result.transactionHash);
+            return result.transactionHash;
+        }
+        catch (error) {
+            console.error("❌ NFT avatar registration failed:", error);
+            throw error;
+        }
+    }
+    /**
+     * Query a registered NFT avatar for a cosmos address
+     *
+     * @param cosmosAddress - The cosmos address to look up
+     * @returns The NFT avatar data if registered, or null if not found
+     */
+    async queryNftAvatar(cosmosAddress) {
+        try {
+            const response = await fetch(`${this.config.restEndpoint}/pokerchain/poker/nft_avatar/${encodeURIComponent(cosmosAddress)}`);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    return null;
+                }
+                throw new Error(`Failed to query NFT avatar: ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (!data.contract_address || !data.token_id) {
+                return null;
+            }
+            return {
+                cosmosAddress: data.cosmos_address || cosmosAddress,
+                ethAddress: data.eth_address || "",
+                contractAddress: data.contract_address,
+                tokenId: data.token_id
+            };
+        }
+        catch (error) {
+            console.error("❌ queryNftAvatar() failed:", error);
+            throw error;
+        }
+    }
 }
 /**
  * Create a signing client with a wallet