如何从Near SDK的Promise中获取u128返回值？

根据你的场景（Rust环境+合约Promise），分两种核心情况处理：

一、合约内跨合约调用（Near合约开发场景） #

Near合约中的Promise是链上异步操作，并非Rust标准库的Future，因此无法直接使用普通async/await。需通过回调函数+解析Promise结果来获取u128值：

示例代码 #

use near_sdk::{env, near_bindgen, Promise, PromiseResult, borsh::{self, BorshDeserialize, BorshSerialize}};

#[near_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
pub struct YourContract {}

#[near_bindgen]
impl YourContract {
    // 发起跨合约调用的主函数
    pub fn fetch_remote_u128(&self, target_contract: String) -> Promise {
        // 调用目标合约的指定方法（假设目标合约有返回u128的`get_u128_value`方法）
        Promise::new(target_contract)
            .function_call(
                "get_u128_value".to_string(),
                b"{}".to_vec(), // 无参数时传空字节数组
                0, // 不附加NEAR代币
                env::prepaid_gas() / 2, // 分配一半Gas给跨合约调用
            )
            // 绑定回调函数处理返回结果
            .then(ext_self::handle_u128_result(
                env::current_account_id(),
                0,
                env::prepaid_gas() / 2, // 剩余Gas分配给回调执行
            ))
    }

    // 回调函数：解析Promise返回的u128值
    pub fn handle_u128_result(&self) -> u128 {
        match env::promise_result(0) { // 获取第一个Promise的结果（索引0对应发起的跨合约调用）
            PromiseResult::Successful(raw_data) => {
                // 把字节数据反序列化为u128（Near合约默认用Borsh序列化）
                borsh::from_slice::<u128>(&raw_data)
                    .expect("Failed to deserialize u128 from result")
            }
            PromiseResult::Failed => {
                env::panic_str("Cross-contract call failed");
            }
        }
    }
}

// 定义外部回调的扩展类型
#[near_bindgen]
pub struct ExtSelf;

#[near_bindgen]
impl ExtSelf {
    pub fn handle_u128_result(&self) -> Promise {
        Promise::new(env::current_account_id())
            .function_call(
                "handle_u128_result".to_string(),
                b"{}".to_vec(),
                0,
                env::prepaid_gas(),
            )
    }
}

关键说明：

• 用env::promise_result(0)获取跨合约调用的结果，参数0对应第一个发起的Promise
• 通过Borsh反序列化将原始字节转为u128，这是Near合约的标准序列化方式

二、外部客户端调用（如使用near-api-js） #

如果是从前端/客户端调用合约方法，此时可以直接使用标准的async/await：

示例代码 #

import { connect, Contract } from 'near-api-js';

async function getRemoteU128() {
    // 连接Near网络
    const near = await connect({
        networkId: 'testnet', // 按需切换为mainnet或自定义网络
        keyStore: /* 你的密钥库配置，如BrowserLocalStorageKeyStore */
    });

    // 初始化目标合约实例
    const targetContract = new Contract(
        await near.account('your-wallet-account-id'),
        'target-contract-id.near',
        {
            viewMethods: ['get_u128_value'], // 目标合约的view方法（只读）
            changeMethods: []
        }
    );

    // 调用并获取u128值（near-js会自动处理大数类型）
    const u128Value = await targetContract.get_u128_value();
    console.log('Received u128 value:', u128Value);
    return u128Value;
}

getRemoteU128();

内容的提问来源于stack exchange，提问作者marethyu