BlockChyp Rust SDK

这是 Rust 的 SDK。像所有 BlockChyp SDK 一样，它为 BlockChyp 网关和 BlockChyp 支付终端提供完整的客户端。

安装

BlockChyp SDK 可通过 Cargo 安装。输入以下命令将 BlockChyp 添加到您的 Cargo.toml 中。

cargo add blockchyp

简单示例

运行您的第一个交易很简单。确保您有 BlockChyp 终端，激活它，并生成一组 API 密钥。

use ::blockchyp::*;

fn main() {
    let creds = APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    let client = Client::new(creds);

    let mut request = AuthorizationRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        amount: "55.00".to_string(),
        ..Default::default()
    };

    let (response, err) = client.charge(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
}

响应包含您完成交易处理所需的所有信息。特别重要的是 ReceiptSuggestions 结构，它包含所有必需或推荐用于 PCI 或 EMV 合规性的字段。

其他文档

完整文档可以在我们的 开发者文档门户 上找到。

获取开发者套件

为了测试您与真实终端的集成，您需要一个 BlockChyp 开发者套件。我们的套件包括一个功能齐全的支付终端和测试 PIN 加密密钥。每个套件都包括一套全面的测试卡，包括每个主要卡品牌的测试卡和输入方式，包括非接触式和接触 EMV 以及磁条卡。每个套件还包括我们的区块链礼品卡系统的测试礼品卡。

BlockChyp 开发者程序的访问目前仅限邀请，但您可以通过联系我们的工程团队 [email protected] 请求邀请。

您还可以在我们的 YouTube 频道 上查看许多长篇演示并了解更多关于我们的信息。

交易代码示例

您不想阅读文字，您想要示例。以下是使用 BlockChyp Rust SDK 可以完成的一些操作及其基本示例的简要概述。

支付端点

这些是用于在BlockChyp中执行和操作支付交易的核心理解API。

收费

• API凭证类型：商家
• 所需角色：支付API访问

我们最受欢迎的交易执行标准授权和捕获。这是最基本的支付交易，通常用于传统零售。

收费交易可以使用支付终端来捕获支付或使用之前注册的支付令牌。

终端交易

对于终端交易，请确保使用terminalName属性传递终端名称。

令牌交易

如果您有支付令牌，省略terminalName属性，并通过token属性传递令牌。

卡号和磁条

您还可以传递PAN和磁条，但您可能不应该这样做，因为这会将您置于PCI范围内，而POS入侵的最常见途径是键盘记录。如果您使用终端进行手动卡输入，您将绕过可能恶意运行的点-of-sale系统中的任何键盘记录器。

常见变化

• 礼品卡兑换：在BlockChyp中没有专门用于礼品卡兑换的API。只需执行普通的收费交易即可。如果客户刷礼品卡，我们的终端将识别礼品卡并执行礼品卡兑换。请注意，如果由于某些原因，礼品卡的原购买交易与欺诈或退货相关联，则交易将被拒绝。
• EBT：将card_type字段设置为blockchyp::CardType::EBT以处理EBT SNAP交易。请注意，测试EBT交易始终假定余额为100.00美元，因此超过该金额的测试EBT交易可能会被拒绝。
• 现金退款：要启用借记交易的现金退款，请设置cash_back字段。如果显示的卡不是借记卡，则忽略cash_back字段。
• 手动卡输入：将manual_entry字段设置为启用手动卡输入。当芯片和 MSR 不可用时或用于更安全的电话订单时，这是一个很好的备用选项。您甚至可以将manual_entry字段与设置为blockchyp::CardType::EBT的card_type字段结合起来，用于手动EBT卡输入。
• 内联令牌化：您可以通过设置enroll字段，在内联收费交易中注册支付方式。您将在响应中获得一个令牌。如果您还传递客户数据，您甚至可以将令牌绑定到客户记录。
• 提示小费：如果您想在授权之前提示客户支付小费，请设置prompt_for_tip字段。这对于点餐支付和其他与服务相关的场景很适用。
• 现金折扣和附加费：surcharge和cash_discount字段可以一起使用以支持现金折扣或附加费问题。有关详细信息，请参阅现金折扣文档。
• 加密货币：可以使用cryptocurrency字段将标准卡显示屏幕切换到加密货币屏幕。字段值可以是启用任何支持的加密货币的ANY，也可以是单个货币代码，例如比特币的BTC。

use blockchyp;
use std::error::Error;

fn charge_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::AuthorizationRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        amount: "55.00".to_string(),
        ..Default::default()
    };
    let (response, err) = client.charge(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    charge_example()?;
    println!("Example completed successfully!");
    Ok(())
}

预先授权

• API凭证类型：商家
• 所需角色：支付API访问

预先授权会冻结资金，必须在之后进行捕获。这在最终交易金额可能发生变化的情况下使用。一个常见的例子是高级餐饮，需要在最终结算前调整小费。

预先授权的另一个用例是电子商务。通常，在线订单在下单时进行预先授权，然后在发货时进行捕获。

预先授权可以使用支付终端进行捕获支付或使用之前注册的支付令牌。

终端交易

对于终端交易，请确保使用terminalName属性传递终端名称。

令牌交易

如果您有支付令牌，省略terminalName属性，并通过token属性传递令牌。

卡号和磁条

您还可以传递PAN和磁条，但可能不应该这样做，因为这会使您进入PCI范围，而POS系统漏洞的最常见途径是键盘记录。如果您使用终端进行手动卡输入，您将绕过可能恶意运行的任何键盘记录器。

加密货币

请注意，预先授权不支持加密货币。

常见变化

• 手动卡输入：将manual_entry字段设置为启用手动卡输入。当芯片和MSR不可用时，作为备份很好，或者用于更安全的电话订单。您甚至可以将manual_entry字段与card_type设置为blockchyp::CardType::EBT结合起来，以进行手动EBT卡输入。
• 行内令牌化：您可以通过设置enroll字段，在交易过程中在线将支付方式注册到令牌保险库中。您将在响应中获得一个令牌。如果您还传递客户数据，您甚至可以将令牌绑定到客户记录。
• 提示小费：如果您想在授权之前提示客户小费，请设置prompt_for_tip字段。您可以在预先授权中提示小费，尽管这不是一个非常常见的做法。
• 现金折扣和附加费：surcharge和cash_discount字段可以一起使用以支持现金折扣或附加费问题。有关详细信息，请参阅现金折扣文档。

use blockchyp;
use std::error::Error;

fn preauth_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::AuthorizationRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        amount: "27.00".to_string(),
        ..Default::default()
    };
    let (response, err) = client.preauth(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    preauth_example()?;
    println!("Example completed successfully!");
    Ok(())
}

捕获预先授权

• API凭证类型：商家
• 所需角色：支付API访问

此API允许您捕获之前批准的预先授权。

您需要确保传入原始预先授权交易返回的交易ID，以便我们知道我们要捕获哪个交易。如果您想捕获与预先授权金额完全相同的交易，只需传入交易ID即可。

如果您需要调整总额，可以通过传入新的amount来实现。我们还建议您传入更新的tax和tip金额，因为这有时可以降低您的交易费率。（例如，二级处理。）

use blockchyp;
use std::error::Error;

fn capture_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::CaptureRequest{
        test: true,
        transaction_id: "<ORIGINAL TRANSACTION ID>".to_string(),
        amount: "32.00".to_string(),
        ..Default::default()
    };
    let (response, err) = client.capture(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    capture_example()?;
    println!("Example completed successfully!");
    Ok(())
}

退款

• API凭证类型：商家
• 所需角色：支付API访问

这不是理想的情况，但有时客户想要退款。

我们的退款API允许您通过在几种不同的场景中执行退款来应对这种不愉快的情况。

最抗欺诈的方法是在之前交易的情况下执行退款。您应该始终跟踪BlockChyp响应中返回的交易ID。要全额退款先前的交易，只需在退款请求中传入原始交易ID即可。

部分退款

对于部分退款，只需传入与交易ID一起的金额。唯一的规则是金额必须等于或小于原始交易金额。只要退还的总额不超过原始金额，您就可以对同一原始交易执行多次部分退款。

令牌化退款

您还可以使用令牌来执行退款。传入令牌而不是交易ID和所需的退款金额。

自由退款

当您在没有引用先前交易的情况下执行退款时，我们称此为自由退款。

我们不推荐这种类型的退款，但它是允许的。如果您一定要这样做，请传递一个终端名称和金额。

您可以通过将 manual_entry 字段传递到自由范围退款请求中来执行手动或按键退款。

礼品卡退款

在之前的交易背景下允许礼品卡退款，但不允许自由范围礼品卡退款。如果您需要向礼品卡添加更多资金，请使用礼品卡激活API。

存储和转发支持

当终端退回到存储和转发模式时，不允许退款。

自动取消

如果在原始交易批次关闭之前，执行了引用先前交易的完整退款，则该退款将自动转换为取消。这可以为商家节省一点钱。

加密货币

请注意，不支持加密货币退款。您必须从您的加密货币钱包手动退款加密货币交易。

use blockchyp;
use std::error::Error;

fn refund_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::RefundRequest{
        transaction_id: "<PREVIOUS TRANSACTION ID>".to_string(),
        amount: "5.00".to_string(),
        ..Default::default()
    };
    let (response, err) = client.refund(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    refund_example()?;
    println!("Example completed successfully!");
    Ok(())
}

取消

• API凭证类型：商家
• 所需角色：支付API访问

错误总是会发生。如果您不小心进行了交易，可以使用此API取消它。所需的一切只是传递一个交易ID，并在原始交易批次关闭之前执行取消。

取消与EBT和礼品卡交易一起使用时无需额外参数。

加密货币

请注意，不支持加密货币取消。您必须从您的加密货币钱包手动退款加密货币交易。

use blockchyp;
use std::error::Error;

fn void_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::VoidRequest{
        test: true,
        transaction_id: "<PREVIOUS TRANSACTION ID>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.void(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    void_example()?;
    println!("Example completed successfully!");
    Ok(())
}

超时反转

• API凭证类型：商家
• 所需角色：支付API访问

支付交易需要一个稳定的网络才能正常工作，而没有任何网络始终是稳定的。超时反转是在不稳定网络条件下重试支付时防止意外对消费者重复收费的强大防线。

我们强烈建议开发者在任何费用、预授权或退款交易超时时使用此API。如果您没有从BlockChyp收到明确的响应，您不能确定交易是否已通过。

在这种情况下，最佳做法是发送超时反转请求。超时反转会检查交易，如果存在则取消。

唯一的限制是，开发者在执行费用、预授权和退款交易时必须使用 transactionRef 属性（CLI中的 txRef）。

此要求的原因是，如果系统从未收到对交易的明确响应，系统就永远不会收到BlockChyp生成的交易ID。我们必须退回到交易参考来识别交易。

加密货币

请注意，不支持加密货币退款。您必须从您的加密货币钱包手动退款加密货币交易。

use blockchyp;
use std::error::Error;

fn reverse_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::AuthorizationRequest{
        transaction_ref: "<LAST TRANSACTION REF>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.reverse(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    reverse_example()?;
    println!("Example completed successfully!");
    Ok(())
}

礼品卡激活

• API凭证类型：商家
• 所需角色：支付API访问

此API激活或为BlockChyp礼品卡添加价值。只需传递终端名称和要添加到卡的金额。一旦客户刷卡，终端将使用磁条上的密钥向卡添加价值。

您无需以不同的方式处理新的礼品卡激活或礼品卡充值。终端固件将自行确定要执行的操作，同时返回礼品卡的新余额。

这是系统中最接近BlockChyp区块链DNA的部分。BlockChyp礼品卡系统实际上并不使用礼品卡号码。这意味着它们不能被盗。

BlockChyp使用椭圆曲线公钥来识别卡片。礼品卡交易实际上是使用这些密钥签名的块。这意味着网络中没有发送共享秘密。要跟踪BlockChyp礼品卡，保留在礼品卡激活期间返回的 公钥。那是礼品卡的椭圆曲线公钥。

我们有时会在礼品卡上打印数字，但实际上这些是公钥一部分的十进制编码散列，使我们的礼品卡看起来对普通人来说很正常。它们可用于余额检查，并在在线礼品卡授权中发挥查找作用，但除此之外用处不大。

作废和撤销

礼品卡激活可以像任何其他BlockChyp交易一样作废和撤销。使用交易ID或交易参考来识别礼品激活交易，就像您通常用于作废或撤销传统支付交易一样。

导入礼品卡

BlockChyp确实具有从传统礼品卡平台导入礼品卡责任的能力。不幸的是，BlockChyp不支持在第三方系统上激活卡片。然而，您可以导入您未结清的礼品卡，客户可以在终端上像BlockChyp的标准礼品卡一样刷卡。

访问此功能不需要特殊编码。网关和终端固件会为您处理所有事情。

第三方礼品卡网络

BlockChyp目前不提供对其他礼品卡平台的任何原生支持，除了导入礼品卡责任。我们确实有一个白名单系统，可以用于支持您自己的自定义礼品卡实现。在我们可以允许一个BIN范围白名单之前，我们有一个安全审查流程，所以如果您需要白名单一个BIN范围，请联系[email protected]。

use blockchyp;
use std::error::Error;

fn gift_activate_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::GiftActivateRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        amount: "50.00".to_string(),
        ..Default::default()
    };
    let (response, err) = client.gift_activate(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.approved {
		println!("approved");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    gift_activate_example()?;
    println!("Example completed successfully!");
    Ok(())
}

余额

• API凭证类型：商家
• 所需角色：支付API访问

此API检查礼品卡或EBT卡余额。

礼品卡余额检查

对于礼品卡，传入终端名称，客户将被提示在该终端上刷卡。剩余余额将短暂显示在终端屏幕上，API响应将包括礼品卡的公钥和剩余余额。

EBT余额检查

所有EBT交易都需要PIN码，因此要检查EBT卡余额，您需要传入与正常EBT交易相同的ebt标志。客户将被提示刷卡并输入PIN码。如果一切正常，卡的剩余余额将在终端上显示给客户，并随API响应返回。

测试礼品卡余额检查

测试礼品卡余额检查与真实礼品卡没有区别。您必须首先激活测试礼品卡才能测试余额检查。测试礼品卡是实际存在于我们并行测试区块链上的区块链卡。

测试EBT礼品卡余额检查

所有测试EBT交易都假定起始余额为$100.00。因此，测试EBT余额检查总是返回$100.00的余额。

use blockchyp;
use std::error::Error;

fn balance_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::BalanceRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        card_type: blockchyp::CardType::EBT,
        ..Default::default()
    };
    let (response, err) = client.balance(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    balance_example()?;
    println!("Example completed successfully!");
    Ok(())
}

关闭批次

• API凭证类型：商家
• 所需角色：支付API访问

此API将在当前处于打开状态时关闭商家的批次。

默认情况下，商家批次将在当地时间凌晨3点自动关闭。自动批次关闭时间可以在商家配置文件中更改，也可以完全禁用。

如果禁用了自动批次关闭，您将需要使用此API手动关闭批次。

use blockchyp;
use std::error::Error;

fn close_batch_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::CloseBatchRequest{
        test: true,
        ..Default::default()
    };
    let (response, err) = client.close_batch(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    close_batch_example()?;
    println!("Example completed successfully!");
    Ok(())
}

发送支付链接

• API凭证类型：商家
• 所需角色：支付API访问

此API允许您向客户发送发票并通过BlockChyp托管支付页面捕获支付。

如果您设置了autoSend标志，BlockChyp将为您向客户发送包含支付链接的基本发票电子邮件。如果您希望对电子邮件消息的外观有更多控制，您可以选择不设置autoSend标志，并自行发送客户电子邮件。

此API有很多可选参数，但至少您需要传递总金额、客户姓名和电子邮件地址。（除非您使用cashier标志。）

客户信息

除非您使用cashier标志，否则您必须指定一个客户；要么通过在行内创建新的客户记录，要么通过传递现有的客户ID或客户引用。

行项目级数据

这不是强制性的，但我们强烈建议在每次请求中发送行项目级细节。这将使发票看起来更完整，行项目级数据的格式与终端行项目显示使用的格式完全相同，因此可以使用相同的代码来支持这两个区域。

描述

您还可以提供一种自由形式的描述或消息，以便在发票底部附近显示。通常这是一些感谢信或指示。

条款和条件

您可以在请求中包含长形式的合同语言，并在同时捕获条款和条件时接受它们。

该接口与用于终端基于的条款和条件API的接口相同，您可以通过tcContent直接传递内容，或通过预先配置的模板通过tcAlias传递。当将协议接受纳入发送链接请求时，条款和条件日志也将更新。

自动发送

BlockChyp不会自动发送电子邮件通知。这种安全措施可以防止在不期望的情况下发送真实的电子邮件。如果您希望BlockChyp为您发送电子邮件，只需在所有请求中添加autoSend标志即可。

加密货币

如果商家配置为支持加密货币交易，则支付页面将显示额外的UI小部件，允许客户切换到加密货币支付方式。

令牌化

将enroll标志添加到发送链接请求中，以便将支付方式注册到令牌保险库中。

将enrollOnly标志添加到令牌保险库中注册支付方式，而不会立即进行任何支付。支付链接将要求用户提供其支付信息，并通知他们他们不会立即被收费，但他们的支付可能用于未来的交易。

收银台面对卡片输入

BlockChyp也可以用于生成内部/收银台面对的卡片输入页面。这是为那些可能需要接听电话订单而没有可用的终端的情况而设计的。

如果您传递了cashier标志，则不会发送电子邮件，您可以在浏览器或iframe中加载链接进行支付输入。当使用cashier标志时，将忽略autoSend标志。

请注意，不支持在收银台面对支付输入中使用加密货币。

支付通知

当客户成功提交支付时，商家将收到一封电子邮件通知他们已收到支付。

实时回调通知

电子邮件通知很好，但您可能希望您的系统在支付事件发生时立即通知。通过使用可选的callbackUrl请求属性，您可以在每次用户提交支付时（无论批准与否）指定一个URL，将授权响应发布到该URL。

响应将以JSON编码的POST请求形式发送，并将与所有BlockChyp收费和预授权交易响应的格式完全相同。

状态轮询

如果实时回调在您的环境中不实用或不必要，您始终可以使用下面描述的支付链接状态API。

使用状态轮询的发送链接API的一个常见用例是路边取货。当顾客到达时，系统可以检查支付链接状态以确保已支付，而无需创建后台线程不断轮询状态更新。

use blockchyp;
use std::error::Error;

fn send_payment_link_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::PaymentLinkRequest{
        transaction_ref: "<TX REF>".to_string(),
        amount: "199.99".to_string(),
        description: "Widget".to_string(),
        subject: "Widget invoice".to_string(),
        transaction: Some(blockchyp::TransactionDisplayTransaction{
            subtotal: "195.00".to_string(),
            tax: "4.99".to_string(),
            total: "199.99".to_string(),
            items: Some(vec![
                blockchyp::TransactionDisplayItem{
                    description: "Widget".to_string(),
                    price: "195.00".to_string(),
                    quantity: 1.0,
                    ..Default::default()
                },

            ]),
            ..Default::default()
        }),
        auto_send: true,
        customer: blockchyp::Customer{
            customer_ref: "Customer reference string".to_string(),
            first_name: "FirstName".to_string(),
            last_name: "LastName".to_string(),
            company_name: "Company Name".to_string(),
            email_address: "[email protected]".to_string(),
            sms_number: "(123) 123-1231".to_string(),
            ..Default::default()
        },
        ..Default::default()
    };
    let (response, err) = client.send_payment_link(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    send_payment_link_example()?;
    println!("Example completed successfully!");
    Ok(())
}

重新发送支付链接

• API凭证类型：商家
• 所需角色：支付API访问

此API会重新发送之前创建的支付链接。如果支付链接已过期、已取消或已被支付，将返回错误。

use blockchyp;
use std::error::Error;

fn resend_payment_link_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::ResendPaymentLinkRequest{
        link_code: "<PAYMENT LINK CODE>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.resend_payment_link(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    resend_payment_link_example()?;
    println!("Example completed successfully!");
    Ok(())
}

取消支付链接

• API凭证类型：商家
• 所需角色：支付API访问

此API可以取消支付链接。

use blockchyp;
use std::error::Error;

fn cancel_payment_link_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::CancelPaymentLinkRequest{
        link_code: "<PAYMENT LINK CODE>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.cancel_payment_link(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    cancel_payment_link_example()?;
    println!("Example completed successfully!");
    Ok(())
}

支付链接状态

• API凭证类型：商家
• 所需角色：支付API访问

此API允许您检查支付链接的状态，包括交易数据和尝试交易的完整历史。

当您想检查支付链接的状态时（与交易状态相比），这是首选的真实来源和最佳实践。由于与单个支付链接关联的多个交易的模糊性，交易状态API并不理想。

您必须传递与支付链接相关的linkCode值。在创建支付链接时，此值包含在BlockChyp的响应中。

use blockchyp;
use std::error::Error;

fn payment_link_status_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::PaymentLinkStatusRequest{
        link_code: "<PAYMENT LINK CODE>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.payment_link_status(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    payment_link_status_example()?;
    println!("Example completed successfully!");
    Ok(())
}

交易状态

• API凭证类型：商家
• 所需角色：支付API访问

此API返回任何交易的当前状态。您可以通过BlockChyp分配的交易ID或您自己的交易参考来查找交易。

您应始终使用全局唯一的交易参考值，但在重复交易参考的情况下，将返回与您的交易参考匹配的最新交易。

use blockchyp;
use std::error::Error;

fn transaction_status_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::TransactionStatusRequest{
        transaction_id: "<TRANSACTION ID>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.transaction_status(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    transaction_status_example()?;
    println!("Example completed successfully!");
    Ok(())
}

现金折扣

• API凭证类型：商家
• 所需角色：支付API访问

此API计算现金交易的附加费、现金折扣和总金额。

如果您正在使用BlockChyp的现金折扣功能，可以使用此端点确保真实现金交易的数字和收据与BlockChyp处理的交易保持一致。

use blockchyp;
use std::error::Error;

fn cash_discount_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::CashDiscountRequest{
        amount: "100.00".to_string(),
        cash_discount: true,
        surcharge: true,
        ..Default::default()
    };
    let (response, err) = client.cash_discount(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    cash_discount_example()?;
    println!("Example completed successfully!");
    Ok(())
}

批量历史

• API凭证类型：商家
• 所需角色：支付API访问

此端点允许开发者查询网关的商户批量历史。数据将按打开日期降序返回，最新批量首先返回。结果将包括有关批量的基本信息。考虑使用批量详细信息API获取特定批量的更多详细信息。

限制结果

此API将返回最多250个结果。使用maxResults属性进一步限制最大结果数，并使用startIndex属性浏览跨越多个查询的结果。

例如，如果您想获取最新的十个批量，请将maxResults的值设置为10。请注意，startIndex是从零开始的。使用值为0来获取数据集中的第一个批量。

按日期范围过滤

您还可以通过日期过滤结果。使用startDate和endDate属性仅返回那些在指定日期之间打开的批量。您可以使用startDate和endDate，并且可以将日期过滤器与maxResults和startIndex结合使用。

use blockchyp;
use std::error::Error;

fn batch_history_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::BatchHistoryRequest{
        max_results: 250,
        start_index: 0,
        ..Default::default()
    };
    let (response, err) = client.batch_history(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    batch_history_example()?;
    println!("Example completed successfully!");
    Ok(())
}

批量详细信息

• API凭证类型：商家
• 所需角色：支付API访问

此API允许开发者获取特定批量的详细信息，包括捕获量、礼品卡活动、预期存款和按终端分解的捕获量。

唯一必需的请求参数是batchId。批量ID与每个交易响应一起返回，可以使用批量历史API发现。

use blockchyp;
use std::error::Error;

fn batch_details_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::BatchDetailsRequest{
        batch_id: "<BATCH ID>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.batch_details(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    batch_details_example()?;
    println!("Example completed successfully!");
    Ok(())
}

交易历史

• API凭证类型：商家
• 所需角色：支付API访问

此端点提供了多种筛选交易历史的方法。

默认情况下，如果没有过滤属性，此端点将返回最近的250笔交易。

限制结果

此API将返回单个查询中的最多50个结果。使用maxResults属性进一步限制最大结果数，并使用startIndex属性分页浏览跨越多个查询的结果。

例如，如果您想获取最近的十个批次，请将maxResults的值传递为10。请注意，startIndex是从0开始的。使用值0获取数据集中的第一条交易。

按日期范围过滤

您还可以通过日期过滤结果。使用startDate和endDate属性仅返回在指定日期之间进行的交易。您可以使用startDate或endDate，并且可以将日期过滤器与maxResults和startIndex一起使用。

按批次过滤

要限制结果仅限于单个批次，请传递batchId参数。

按终端过滤

要限制结果仅限于单个终端上执行的交易，请传递终端名称。

组合过滤器

上述所有过滤器都不是互斥的。您可以在单个请求中组合上述任何属性，以将交易结果限制为更窄的结果集。

搜索交易历史

您可以通过传递带有query选项的搜索条件来搜索交易历史。搜索系统将匹配金额（请求和授权）、卡号最后四位、持卡人姓名和授权代码。

请注意，当使用搜索查询时，不支持终端名称或批次ID过滤器。

use blockchyp;
use std::error::Error;

fn transaction_history_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::TransactionHistoryRequest{
        max_results: 10,
        batch_id: "<BATCH ID>".to_string(),
        ..Default::default()
    };
    let (response, err) = client.transaction_history(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    transaction_history_example()?;
    println!("Example completed successfully!");
    Ok(())
}

列出队列中的交易

• API凭证类型：商家
• 所需角色：支付API访问

返回终端上队列中的交易的交易引用列表。可以使用交易状态API检索交易的详细信息。

use blockchyp;
use std::error::Error;

fn list_queued_transactions_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::ListQueuedTransactionsRequest{
        terminal_name: "Test Terminal".to_string(),
        ..Default::default()
    };
    let (response, err) = client.list_queued_transactions(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    list_queued_transactions_example()?;
    println!("Example completed successfully!");
    Ok(())
}

删除队列中的交易

• API凭证类型：商家
• 所需角色：支付API访问

从终端中删除一个或所有队列中的交易。如果传递的交易引用为*，则整个终端队列将被清除。如果传递的交易引用未在终端上排队，则返回错误。

use blockchyp;
use std::error::Error;

fn delete_queued_transaction_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::DeleteQueuedTransactionRequest{
        terminal_name: "Test Terminal".to_string(),
        transaction_ref: "*".to_string(),
        ..Default::default()
    };
    let (response, err) = client.delete_queued_transaction(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    delete_queued_transaction_example()?;
    println!("Example completed successfully!");
    Ok(())
}

终端管理端点

这些API支持终端管理功能以及如行项目显示、消息和交互式提示等附加终端功能。
这些功能可以用来扩展销售点系统的功能。

终端Ping

• API凭证类型：商家
• 所需角色：支付API访问

这个简单的测试交易有助于确保与支付终端的良好通信，通常是在开发中运行的第一项测试。

它测试与终端的通信，如果一切正常，则返回积极响应。它以相同的方式在本地或云中继模式下工作。

如果您收到积极响应，则已成功验证以下所有内容

• 终端在线。
• 有有效的路由到终端。
• API凭证有效。

use blockchyp;
use std::error::Error;

fn ping_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::PingRequest{
        terminal_name: "Test Terminal".to_string(),
        ..Default::default()
    };
    let (response, err) = client.ping(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    ping_example()?;
    println!("Example completed successfully!");
    Ok(())
}

终端定位

• API凭证类型：商家
• 所需角色：支付API访问

此端点返回终端的路由和位置信息。

结果将指示终端是否处于云中继模式，如果终端处于本地模式，将返回本地IP地址。

终端还将返回终端的公钥。

use blockchyp;
use std::error::Error;

fn locate_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::LocateRequest{
        terminal_name: "Test Terminal".to_string(),
        ..Default::default()
    };
    let (response, err) = client.locate(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    locate_example()?;
    println!("Example completed successfully!");
    Ok(())
}

终端清除

• API凭证类型：商家
• 所需角色：支付API访问

此API中断终端可能正在执行的操作，并将其返回到空闲状态。

use blockchyp;
use std::error::Error;

fn clear_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::ClearTerminalRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        ..Default::default()
    };
    let (response, err) = client.clear(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    clear_example()?;
    println!("Example completed successfully!");
    Ok(())
}

终端状态

• API凭证类型：商家
• 所需角色：支付API访问

此API返回支付终端的当前状态。通常用作在发送新交易之前确定终端是否忙碌的方法。

如果终端忙碌，idle 将为 false，并且 status 字段将返回一个短字符串，指示当前正在进行的交易类型。系统还会在 since 字段中返回最后状态变化的时间戳。

响应中的 cardInSlot 字段将指示卡片是否当前在读卡器插槽中。

如果系统正在运行支付交易，并且您明智地传递了交易引用，此 API 还将返回正在进行的交易的交易引用。

下表列出了所有可能的状态响应。

use blockchyp;
use std::error::Error;

fn terminal_status_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::TerminalStatusRequest{
        terminal_name: "Test Terminal".to_string(),
        ..Default::default()
    };
    let (response, err) = client.terminal_status(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminal_status_example()?;
    println!("Example completed successfully!");
    Ok(())
}

Capture Signature

• API凭证类型：商家
• 所需角色：支付API访问

此端点从终端捕获手写签名并返回图像。

与条款和条件 API 不同，此端点执行基本的签名捕获，不显示协议或存档签名。

在底层，签名以专有矢量格式捕获，必须将其转换为常见光栅格式，才能用于大多数应用程序。至少，您必须使用 sigFormat 参数指定一个图像格式。目前支持 JPG 和 PNG。

默认情况下，图像以十六进制编码的二进制形式返回。您可以使用 sigFile 参数将二进制图像输出重定向到文件。

您还可以通过传递 sigWidth 参数来缩放输出图像到您首选的宽度。图像将缩放到该宽度，同时保留原始图像的纵横比。

use blockchyp;
use std::error::Error;

fn capture_signature_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::CaptureSignatureRequest{
        terminal_name: "Test Terminal".to_string(),
        sig_format: blockchyp::SignatureFormat::PNG,
        sig_width: 200,
        ..Default::default()
    };
    let (response, err) = client.capture_signature(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    capture_signature_example()?;
    println!("Example completed successfully!");
    Ok(())
}

New Transaction Display

• API凭证类型：商家
• 所需角色：支付API访问

此 API 将总计和行项目级数据发送到终端。

至少，您应将总计信息作为显示请求的一部分发送，包括 total、tax 和 subtotal。

您还可以发送行项目级数据，每个行项目都可以有一个 description、qty、price 和 extended 价格。

如果您未能发送扩展价格，BlockChyp 将将 qty 乘以 price。然而，我们强烈建议您自己预先计算所有字段，以确保一致性。例如，您对浮点数乘法和舍入的处理可能与 BlockChyp 的略有不同。

折扣

您可以选择在显示上以单独的行项目形式显示折扣，其中包含负值，或者将折扣与特定的行项目关联。您可以为带有描述和金额的单独行项目应用任意数量的折扣。

use blockchyp;
use std::error::Error;

fn new_transaction_display_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::TransactionDisplayRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        transaction: Some(blockchyp::TransactionDisplayTransaction{
            subtotal: "60.00".to_string(),
            tax: "5.00".to_string(),
            total: "65.00".to_string(),
            items: Some(vec![
                blockchyp::TransactionDisplayItem{
                    description: "Leki Trekking Poles".to_string(),
                    price: "35.00".to_string(),
                    quantity: 2.0,
                    extended: "70.00".to_string(),
                    discounts: Some(vec![
                        blockchyp::TransactionDisplayDiscount{
                            description: "memberDiscount".to_string(),
                            amount: "10.00".to_string(),
                            ..Default::default()
                        },

                    ]),
                    ..Default::default()
                },

            ]),
            ..Default::default()
        }),
        ..Default::default()
    };
    let (response, err) = client.new_transaction_display(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    new_transaction_display_example()?;
    println!("Example completed successfully!");
    Ok(())
}

更新交易显示

• API凭证类型：商家
• 所需角色：支付API访问

类似于新建交易显示，此变体允许开发人员更新当前在终端上显示的行项目级别数据。

此功能旨在在扫描项目时更新终端显示。您只需向终端发送已更改的信息，通常意味着新的行项目和更新的总计。

如果终端不在行项目显示模式下，并且您调用此端点，第一次调用将表现得像新建交易显示调用。

至少，您应将总计信息作为显示请求的一部分发送，包括 total、tax 和 subtotal。

您还可以发送行项目级数据，每个行项目都可以有一个 description、qty、price 和 extended 价格。

如果您未能发送扩展价格，BlockChyp 将将 qty 乘以 price。然而，我们强烈建议您自己预先计算所有字段，以确保一致性。例如，您对浮点数乘法和舍入的处理可能与 BlockChyp 的略有不同。

折扣

您可以选择在显示上以单独的行项目形式显示折扣，其中包含负值，或者将折扣与特定的行项目关联。您可以为带有描述和金额的单独行项目应用任意数量的折扣。

use blockchyp;
use std::error::Error;

fn update_transaction_display_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::TransactionDisplayRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        transaction: Some(blockchyp::TransactionDisplayTransaction{
            subtotal: "60.00".to_string(),
            tax: "5.00".to_string(),
            total: "65.00".to_string(),
            items: Some(vec![
                blockchyp::TransactionDisplayItem{
                    description: "Leki Trekking Poles".to_string(),
                    price: "35.00".to_string(),
                    quantity: 2.0,
                    extended: "70.00".to_string(),
                    discounts: Some(vec![
                        blockchyp::TransactionDisplayDiscount{
                            description: "memberDiscount".to_string(),
                            amount: "10.00".to_string(),
                            ..Default::default()
                        },

                    ]),
                    ..Default::default()
                },

            ]),
            ..Default::default()
        }),
        ..Default::default()
    };
    let (response, err) = client.update_transaction_display(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    update_transaction_display_example()?;
    println!("Example completed successfully!");
    Ok(())
}

显示消息

• API凭证类型：商家
• 所需角色：支付API访问

此API在支付终端上显示消息。

只需指定目标终端和消息，使用message参数。

use blockchyp;
use std::error::Error;

fn message_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::MessageRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        message: "Thank you for your business.".to_string(),
        ..Default::default()
    };
    let (response, err) = client.message(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    message_example()?;
    println!("Example completed successfully!");
    Ok(())
}

布尔提示

• API凭证类型：商家
• 所需角色：支付API访问

此API提示客户回答是或否的问题。

您可以使用prompt参数指定问题或提示，响应返回在response字段中。

这可以用于多种用例，包括启动忠诚度注册工作流程或面向客户的推荐销售提示。

自定义标题

您可以使用yesCaption和noCaption请求参数覆盖“是”和“否”按钮的标题。

use blockchyp;
use std::error::Error;

fn boolean_prompt_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::BooleanPromptRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        prompt: "Would you like to become a member?".to_string(),
        yes_caption: "Yes".to_string(),
        no_caption: "No".to_string(),
        ..Default::default()
    };
    let (response, err) = client.boolean_prompt(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    boolean_prompt_example()?;
    println!("Example completed successfully!");
    Ok(())
}

文本提示

• API凭证类型：商家
• 所需角色：支付API访问

此API提示客户输入数字或字母数字数据。

由于PCI规则，当响应可以是任何有效字符串时，不允许使用自由格式提示。原因是恶意开发者（当然不是您）可能会使用文本提示要求客户输入卡号或PIN码。

这意味着您不是提供提示，而是提供一个promptType。

目前支持以下提示类型：

• phone：捕获电话号码。
• email：捕获电子邮件地址。
• first-name：捕获名字。
• last-name：捕获姓氏。
• customer-number：捕获客户编号。
• rewards-number：捕获奖励编号。

您可以使用promptType参数指定提示，响应返回在response字段中。

use blockchyp;
use std::error::Error;

fn text_prompt_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let mut request = blockchyp::TextPromptRequest{
        test: true,
        terminal_name: "Test Terminal".to_string(),
        prompt_type: blockchyp::PromptType::Email,
        ..Default::default()
    };
    let (response, err) = client.text_prompt(&mut request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    text_prompt_example()?;
    println!("Example completed successfully!");
    Ok(())
}

列出终端

• API凭证类型：商家 & 合作伙伴
• 所需角色：终端管理

此API返回与商家账户关联的终端的详细信息。

返回所有终端的状态和资源信息，包括终端上当前显示的品牌预览图像。

use blockchyp;
use std::error::Error;

fn terminals_example() -> Result<(), Box<dyn Error>> {
    // sample credentials
    let creds = blockchyp::APICredentials {
        api_key: "ZDSMMZLGRPBPRTJUBTAFBYZ33Q".to_string(),
        bearer_token: "ZLBW5NR4U5PKD5PNP3ZP3OZS5U".to_string(),
        signing_key: "9c6a5e8e763df1c9256e3d72bd7f53dfbd07312938131c75b3bfd254da787947".to_string(),
    };

    // instantiate the client
    let client = blockchyp::Client::new(creds);

    let request = blockchyp::TerminalProfileRequest{

        ..Default::default()
    };
    let (response, err) = client.terminals(&request);

    if let Some(e) = err {
        eprintln!("Unexpected error occurred: {:?}", e);
        return Err(e)
    }

    if response.success {
		println!("Success");
	}

    println!("Response: {:?}", response);
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    terminals_example()?;
    println!("Example completed successfully!");
    Ok(())
}