@mayanfinance/blink-sdk 0.1.8

package/dist/order.js

@@ -0,0 +1,173 @@
+import { fromJson } from "@bufbuild/protobuf";
+import { buildEvmDepositCall, } from "./evm.js";
+import { QuoteResponseSchema, } from "./gen/blink/v1/api_pb.js";
+import { verifyQuote } from "./hash.js";
+import { addSuiDepositCall, addSuiSwapDepositCall, } from "./sui.js";
+import { buildSvmDepositInstructions, buildSvmSwapDepositInstructions, } from "./svm.js";
+export const quoteOf = (response) => response.quote.value;
+export const isSameChainSwap = (response) => response.quote.case === "sameChainSwap";
+export const depositDeadlineOf = (quote) => {
+    if (!quote.depositDeadline) {
+        return undefined;
+    }
+    const parsed = new Date(quote.depositDeadline);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+};
+export const isQuoteExpired = (quote) => {
+    const deadline = depositDeadlineOf(quote);
+    return deadline !== undefined && deadline.getTime() <= Date.now();
+};
+export const assertDepositDeadline = (depositDeadline) => {
+    if (!depositDeadline) {
+        return;
+    }
+    const deadline = new Date(depositDeadline);
+    if (!Number.isNaN(deadline.getTime()) && deadline.getTime() <= Date.now()) {
+        throw new Error("quote deposit deadline passed, request a new quote");
+    }
+};
+const OUTCOMES = {
+    fulfilled: "fulfilled",
+    refunded: "refunded",
+    refund_skipped: "failed",
+    deposit_missing: "failed",
+    refund_failed: "failed",
+    unsupported_deposit: "failed",
+};
+export const orderOutcome = (state) => OUTCOMES[state] ?? "pending";
+export const isTerminalState = (state) => state in OUTCOMES;
+export const isGuaranteedTradeType = (tradeType) => tradeType === "exact_input_guaranteed_output" || tradeType === "exact_output";
+export const explorerTxUrl = (template, tx) => template && tx ? template.replace("{tx}", tx) : undefined;
+export const explorerAddressUrl = (template, address) => template && address ? template.replace("{address}", address) : undefined;
+export const isSourceSwap = (params) => params.srcToken !== params.bridgeTokenSrc;
+export const decodeCrossChainQuote = (json) => {
+    const response = fromJson(QuoteResponseSchema, json);
+    if (response.quote.case !== "crossChain") {
+        throw new Error("expected a cross-chain quote");
+    }
+    const quote = response.quote.value;
+    verifyQuote(quote);
+    assertDepositDeadline(quote.depositDeadline);
+    return quote;
+};
+const paramsOf = (quote) => {
+    if (!quote.orderParams) {
+        throw new Error("quote has no order params");
+    }
+    return quote.orderParams;
+};
+const sameAddress = (a, b) => a.toLowerCase() === b.toLowerCase();
+const referrerKey = (r) => `${r.address.toLowerCase()}:${r.bps}`;
+const sameReferrers = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const keys = new Set(a.map(referrerKey));
+    return b.every((r) => keys.has(referrerKey(r)));
+};
+export const assertOrderMatches = (quote, expected) => {
+    const params = paramsOf(quote);
+    if (params.srcChain !== expected.srcChain ||
+        params.dstChain !== expected.dstChain) {
+        throw new Error("order chains do not match the quote");
+    }
+    if (BigInt(params.amountIn) !== expected.amountIn) {
+        throw new Error("order amount does not match the quote");
+    }
+    if (!sameAddress(params.recipient, expected.recipient)) {
+        throw new Error("order recipient does not match the destination address");
+    }
+    if (!sameAddress(params.refundAddress, expected.refundAddress)) {
+        throw new Error("order refund address does not match");
+    }
+    if (expected.minAmountOut !== undefined &&
+        BigInt(params.minAmountOut) < expected.minAmountOut) {
+        throw new Error("order minimum output is below the quoted minimum, request a new quote");
+    }
+    if (expected.referrers !== undefined &&
+        !sameReferrers(params.referrers, expected.referrers)) {
+        throw new Error("order referrers do not match the requested referrers");
+    }
+};
+export const evmOrderDepositCall = (order, signature) => buildEvmDepositCall({
+    quoteHash: order.quote.quoteHash,
+    params: paramsOf(order.quote),
+    swap: order.swap,
+    directTransfer: order.quote.directTransfer,
+    router: order.chain?.router,
+}, signature);
+export const svmOrderDepositInstructions = async (order, rpcUrl, owner) => {
+    const params = paramsOf(order.quote);
+    const amount = BigInt(params.amountIn);
+    if (!isSourceSwap(params)) {
+        return {
+            instructions: await buildSvmDepositInstructions({
+                rpcUrl,
+                programId: params.routerAddress,
+                owner,
+                token: params.srcToken,
+                amount,
+                quoteHash: order.quote.quoteHash,
+            }),
+            lookupTables: [],
+        };
+    }
+    const swap = order.swap;
+    if (!swap || swap.payload.case !== "svm") {
+        throw new Error("expected svm swap instructions");
+    }
+    const swapProgramSigner = order.chain?.treasury;
+    if (!swapProgramSigner) {
+        throw new Error("svm deposits are unavailable");
+    }
+    return buildSvmSwapDepositInstructions({
+        rpcUrl,
+        chain: params.srcChain,
+        programId: swap.routerAddress,
+        owner,
+        srcToken: params.srcToken,
+        bridgeToken: params.bridgeTokenSrc,
+        amount,
+        minBridgeOut: BigInt(params.minBridgeOut),
+        quoteHash: order.quote.quoteHash,
+        swap: swap.payload.value,
+        swapProgramSigner,
+    });
+};
+export const suiOrderDepositCall = (order, tx, payment) => {
+    const params = paramsOf(order.quote);
+    const escrow = order.chain?.escrow;
+    if (!escrow) {
+        throw new Error("sui deposits are unavailable");
+    }
+    if (isSourceSwap(params)) {
+        const swap = order.swap;
+        if (!swap || swap.payload.case !== "sui") {
+            throw new Error("expected sui swap instructions");
+        }
+        const sender = tx.getData().sender;
+        if (!sender) {
+            throw new Error("sui swap deposits need the transaction sender set");
+        }
+        addSuiSwapDepositCall(tx, {
+            packageId: params.routerAddress,
+            escrowObject: escrow,
+            sender,
+            srcToken: params.srcToken,
+            bridgeToken: params.bridgeTokenSrc,
+            amountIn: BigInt(params.amountIn),
+            minBridgeOut: BigInt(params.minBridgeOut),
+            quoteHash: order.quote.quoteHash,
+            swap: swap.payload.value,
+            payment,
+        });
+        return;
+    }
+    addSuiDepositCall(tx, {
+        packageId: params.routerAddress,
+        escrowObject: escrow,
+        coinType: params.srcToken,
+        quoteHash: order.quote.quoteHash,
+        payment,
+    });
+};

package/dist/sui.d.ts

@@ -0,0 +1,74 @@
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import type { SuiSwapInstructions } from "./gen/blink/v1/api_pb.js";
+export declare const SUI_COIN_TYPE = "0x2::sui::SUI";
+export declare const isNativeSuiToken: (address: string) => boolean;
+export declare const suiBalance: (rpcUrl: string, coinType: string, owner: string) => Promise<bigint>;
+export interface SuiDepositRequest {
+    rpcUrl: string;
+    packageId: string;
+    escrowObject: string;
+    owner: string;
+    coinType: string;
+    amount: bigint;
+    quoteHash: string;
+}
+export interface SuiDepositCall {
+    packageId: string;
+    escrowObject: string;
+    coinType: string;
+    quoteHash: string;
+    payment: TransactionObjectArgument;
+}
+export declare const addSuiDepositCall: (tx: Transaction, call: SuiDepositCall) => void;
+export declare const buildSuiDeposit: (request: SuiDepositRequest) => Promise<Transaction>;
+export declare const sponsorSuiTransaction: (rpcUrl: string, transaction: Transaction, sponsor: string, maxGasBudget: bigint) => Promise<Transaction>;
+export type SuiSwapFragment = typeof bcs.ProgrammableTransaction.$inferType;
+export type SuiFragmentArgument = typeof bcs.Argument.$inferType;
+export interface SuiSwapFragmentRules {
+    sender: string;
+    srcToken: string;
+}
+export declare const suiSwapFragmentOf: (swap: SuiSwapInstructions) => {
+    fragment: SuiSwapFragment;
+    coinOut: SuiFragmentArgument;
+};
+export declare const checkSuiSwapFragment: (fragment: SuiSwapFragment, coinOut: SuiFragmentArgument, rules: SuiSwapFragmentRules) => void;
+export declare const appendSwapFragment: (tx: Transaction, fragment: SuiSwapFragment, payment: TransactionObjectArgument, coinOut: SuiFragmentArgument) => TransactionObjectArgument;
+export interface SuiSwapDepositCall {
+    packageId: string;
+    escrowObject: string;
+    sender: string;
+    srcToken: string;
+    bridgeToken: string;
+    amountIn: bigint;
+    minBridgeOut: bigint;
+    quoteHash: string;
+    swap: SuiSwapInstructions;
+    payment: TransactionObjectArgument;
+}
+export declare const addSuiSwapDepositCall: (tx: Transaction, call: SuiSwapDepositCall) => void;
+export interface SuiSwapDepositRequest {
+    rpcUrl: string;
+    packageId: string;
+    escrowObject: string;
+    owner: string;
+    srcToken: string;
+    bridgeToken: string;
+    amountIn: bigint;
+    minBridgeOut: bigint;
+    quoteHash: string;
+    swap: SuiSwapInstructions;
+}
+export declare const buildSuiSwapDeposit: (request: SuiSwapDepositRequest) => Promise<Transaction>;
+export interface SuiVoucherRedemptionRequest {
+    packageId: string;
+    escrowObject: string;
+    coinType: string;
+    id: string;
+    referrer: string;
+    amount: bigint;
+    signature: string;
+    sender: string;
+}
+export declare const buildSuiVoucherRedemption: (request: SuiVoucherRedemptionRequest) => Transaction;

package/dist/sui.js

@@ -0,0 +1,310 @@
+import { bcs } from "@mysten/sui/bcs";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { Transaction, } from "@mysten/sui/transactions";
+import { fromBase64, normalizeStructTag, normalizeSuiAddress, toHex, } from "@mysten/sui/utils";
+export const SUI_COIN_TYPE = "0x2::sui::SUI";
+export const isNativeSuiToken = (address) => address === SUI_COIN_TYPE;
+const client = (rpcUrl) => new SuiGrpcClient({ network: "mainnet", baseUrl: rpcUrl });
+const hexBytes = (hex) => {
+    const raw = hex.replace(/^0x/, "");
+    const out = new Uint8Array(raw.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(raw.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+};
+export const suiBalance = async (rpcUrl, coinType, owner) => {
+    const { balance } = await client(rpcUrl).getBalance({ owner, coinType });
+    return BigInt(balance.balance);
+};
+const collectCoins = async (rpc, owner, coinType, amount) => {
+    const ids = [];
+    let total = 0n;
+    let cursor;
+    for (;;) {
+        const page = await rpc.listCoins({ owner, coinType, cursor });
+        for (const coin of page.objects) {
+            ids.push(coin.objectId);
+            total += BigInt(coin.balance);
+            if (total >= amount) {
+                return ids;
+            }
+        }
+        if (!page.hasNextPage || !page.cursor) {
+            throw new Error(`insufficient ${coinType} balance for ${owner}`);
+        }
+        cursor = page.cursor;
+    }
+};
+export const addSuiDepositCall = (tx, call) => {
+    tx.moveCall({
+        target: `${call.packageId}::blink::deposit`,
+        typeArguments: [call.coinType],
+        arguments: [
+            tx.object(call.escrowObject),
+            tx.pure.vector("u8", hexBytes(call.quoteHash)),
+            call.payment,
+        ],
+    });
+};
+export const buildSuiDeposit = async (request) => {
+    const rpc = client(request.rpcUrl);
+    const [first, ...rest] = await collectCoins(rpc, request.owner, request.coinType, request.amount);
+    const tx = new Transaction();
+    tx.setSender(request.owner);
+    const primary = tx.object(first);
+    if (rest.length > 0) {
+        tx.mergeCoins(primary, rest.map((id) => tx.object(id)));
+    }
+    const [payment] = tx.splitCoins(primary, [request.amount]);
+    addSuiDepositCall(tx, {
+        packageId: request.packageId,
+        escrowObject: request.escrowObject,
+        coinType: request.coinType,
+        quoteHash: request.quoteHash,
+        payment,
+    });
+    return tx;
+};
+const SPONSORED_BUDGET_MARGIN_BPS = 12500n;
+export const sponsorSuiTransaction = async (rpcUrl, transaction, sponsor, maxGasBudget) => {
+    const rpc = client(rpcUrl);
+    transaction.setGasOwner(sponsor);
+    transaction.setGasPayment([]);
+    transaction.setGasBudget(maxGasBudget);
+    const simulated = await rpc.core.simulateTransaction({
+        transaction: await transaction.build({ client: rpc }),
+        include: { effects: true },
+    });
+    if (simulated.$kind === "FailedTransaction") {
+        throw new Error(`sponsored deposit would fail: ${simulated.FailedTransaction.status.error?.message ?? "unknown"}`);
+    }
+    const { computationCost, storageCost } = simulated.Transaction.effects.gasUsed;
+    const needed = ((BigInt(computationCost) + BigInt(storageCost)) *
+        SPONSORED_BUDGET_MARGIN_BPS) /
+        10000n;
+    transaction.setGasBudget(needed < maxGasBudget ? needed : maxGasBudget);
+    return Transaction.from(await transaction.build({ client: rpc }));
+};
+const rejectSwap = (reason) => {
+    throw new Error(`swap instructions rejected: ${reason}`);
+};
+export const suiSwapFragmentOf = (swap) => ({
+    fragment: bcs.ProgrammableTransaction.parse(fromBase64(swap.fragment)),
+    coinOut: swap.coinOutResult === undefined
+        ? { $kind: "Result", Result: swap.coinOutCommand }
+        : {
+            $kind: "NestedResult",
+            NestedResult: [swap.coinOutCommand, swap.coinOutResult],
+        },
+});
+const inputKind = (input) => input.$kind === "Object" ? input.Object.$kind : input.$kind;
+const commandArguments = (command) => {
+    switch (command.$kind) {
+        case "MoveCall":
+            return command.MoveCall.arguments;
+        case "TransferObjects":
+            return [
+                ...command.TransferObjects.objects,
+                command.TransferObjects.address,
+            ];
+        case "SplitCoins":
+            return [command.SplitCoins.coin, ...command.SplitCoins.amounts];
+        case "MergeCoins":
+            return [command.MergeCoins.destination, ...command.MergeCoins.sources];
+        case "MakeMoveVec":
+            return command.MakeMoveVec.elements;
+        default:
+            return rejectSwap(`command ${command.$kind} is not allowed`);
+    }
+};
+const referencedCommand = (arg) => arg.$kind === "Result"
+    ? arg.Result
+    : arg.$kind === "NestedResult"
+        ? arg.NestedResult[0]
+        : undefined;
+const isSenderInput = (fragment, arg, sender) => {
+    if (arg.$kind !== "Input") {
+        return false;
+    }
+    const input = fragment.inputs[arg.Input];
+    if (input?.$kind !== "Pure") {
+        return false;
+    }
+    const bytes = fromBase64(input.Pure.bytes);
+    return (bytes.length === 32 &&
+        normalizeSuiAddress(toHex(bytes)) === normalizeSuiAddress(sender));
+};
+const isCoinInStandIn = (command, srcToken) => command?.$kind === "MoveCall" &&
+    normalizeSuiAddress(command.MoveCall.package) ===
+        normalizeSuiAddress("0x2") &&
+    command.MoveCall.module === "coin" &&
+    command.MoveCall.function === "zero" &&
+    command.MoveCall.arguments.length === 0 &&
+    command.MoveCall.typeArguments.length === 1 &&
+    normalizeStructTag(command.MoveCall.typeArguments[0]) ===
+        normalizeStructTag(srcToken);
+export const checkSuiSwapFragment = (fragment, coinOut, rules) => {
+    if (!isCoinInStandIn(fragment.commands[0], rules.srcToken)) {
+        rejectSwap("first command is not the input coin stand-in");
+    }
+    for (const input of fragment.inputs) {
+        if (input.$kind !== "Pure" &&
+            !(input.$kind === "Object" && input.Object.$kind === "SharedObject")) {
+            rejectSwap(`input ${inputKind(input)} is not allowed`);
+        }
+    }
+    fragment.commands.forEach((command, index) => {
+        if (index === 0) {
+            return;
+        }
+        for (const arg of commandArguments(command)) {
+            if (arg.$kind === "GasCoin") {
+                rejectSwap("gas coin is not allowed");
+            }
+            if (arg.$kind === "Input" && arg.Input >= fragment.inputs.length) {
+                rejectSwap("argument references a missing input");
+            }
+            if (arg.$kind === "NestedResult" && arg.NestedResult[0] === 0) {
+                rejectSwap("nested result of the input coin stand-in");
+            }
+            const target = referencedCommand(arg);
+            if (target !== undefined && target >= index) {
+                rejectSwap("argument references a later command");
+            }
+        }
+        if (command.$kind === "TransferObjects" &&
+            !isSenderInput(fragment, command.TransferObjects.address, rules.sender)) {
+            rejectSwap("transfer recipient is not the sender");
+        }
+    });
+    const outCommand = referencedCommand(coinOut);
+    if (outCommand === undefined ||
+        outCommand === 0 ||
+        outCommand >= fragment.commands.length) {
+        rejectSwap("output coin does not reference a swap command");
+    }
+};
+export const appendSwapFragment = (tx, fragment, payment, coinOut) => {
+    const inputs = fragment.inputs.map((input) => {
+        if (input.$kind === "Pure") {
+            return tx.pure(fromBase64(input.Pure.bytes));
+        }
+        if (input.$kind === "Object" && input.Object.$kind === "SharedObject") {
+            return tx.sharedObjectRef(input.Object.SharedObject);
+        }
+        return rejectSwap(`input ${inputKind(input)} is not allowed`);
+    });
+    const results = [];
+    const resolve = (arg) => {
+        switch (arg.$kind) {
+            case "Input":
+                return inputs[arg.Input];
+            case "Result":
+                return arg.Result === 0 ? payment : results[arg.Result];
+            case "NestedResult":
+                return results[arg.NestedResult[0]][arg.NestedResult[1]];
+            default:
+                return rejectSwap("gas coin is not allowed");
+        }
+    };
+    fragment.commands.forEach((command, index) => {
+        if (index === 0) {
+            return;
+        }
+        switch (command.$kind) {
+            case "MoveCall":
+                results[index] = tx.moveCall({
+                    target: `${command.MoveCall.package}::${command.MoveCall.module}::${command.MoveCall.function}`,
+                    typeArguments: command.MoveCall.typeArguments,
+                    arguments: command.MoveCall.arguments.map(resolve),
+                });
+                return;
+            case "TransferObjects":
+                results[index] = tx.transferObjects(command.TransferObjects.objects.map(resolve), resolve(command.TransferObjects.address));
+                return;
+            case "SplitCoins":
+                results[index] = tx.splitCoins(resolve(command.SplitCoins.coin), command.SplitCoins.amounts.map(resolve));
+                return;
+            case "MergeCoins":
+                results[index] = tx.mergeCoins(resolve(command.MergeCoins.destination), command.MergeCoins.sources.map(resolve));
+                return;
+            case "MakeMoveVec":
+                results[index] = tx.makeMoveVec({
+                    type: command.MakeMoveVec.type ?? undefined,
+                    elements: command.MakeMoveVec.elements.map(resolve),
+                });
+                return;
+            default:
+                rejectSwap(`command ${command.$kind} is not allowed`);
+        }
+    });
+    return resolve(coinOut);
+};
+export const addSuiSwapDepositCall = (tx, call) => {
+    const { fragment, coinOut } = suiSwapFragmentOf(call.swap);
+    checkSuiSwapFragment(fragment, coinOut, {
+        sender: call.sender,
+        srcToken: call.srcToken,
+    });
+    const bridged = appendSwapFragment(tx, fragment, call.payment, coinOut);
+    tx.moveCall({
+        target: `${call.packageId}::blink::deposit_swap`,
+        typeArguments: [call.srcToken, call.bridgeToken],
+        arguments: [
+            tx.object(call.escrowObject),
+            tx.pure.vector("u8", hexBytes(call.quoteHash)),
+            bridged,
+            tx.pure.u64(call.amountIn),
+            tx.pure.u64(call.minBridgeOut),
+        ],
+    });
+};
+const isSuiCoinType = (coinType) => normalizeStructTag(coinType) === normalizeStructTag(SUI_COIN_TYPE);
+const addPayment = async (tx, rpcUrl, owner, coinType, amount) => {
+    if (isSuiCoinType(coinType)) {
+        const [payment] = tx.splitCoins(tx.gas, [amount]);
+        return payment;
+    }
+    const [first, ...rest] = await collectCoins(client(rpcUrl), owner, coinType, amount);
+    const primary = tx.object(first);
+    if (rest.length > 0) {
+        tx.mergeCoins(primary, rest.map((id) => tx.object(id)));
+    }
+    const [payment] = tx.splitCoins(primary, [amount]);
+    return payment;
+};
+export const buildSuiSwapDeposit = async (request) => {
+    const tx = new Transaction();
+    tx.setSender(request.owner);
+    const payment = await addPayment(tx, request.rpcUrl, request.owner, request.srcToken, request.amountIn);
+    addSuiSwapDepositCall(tx, {
+        packageId: request.packageId,
+        escrowObject: request.escrowObject,
+        sender: request.owner,
+        srcToken: request.srcToken,
+        bridgeToken: request.bridgeToken,
+        amountIn: request.amountIn,
+        minBridgeOut: request.minBridgeOut,
+        quoteHash: request.quoteHash,
+        swap: request.swap,
+        payment,
+    });
+    return tx;
+};
+export const buildSuiVoucherRedemption = (request) => {
+    const tx = new Transaction();
+    tx.setSender(request.sender);
+    tx.moveCall({
+        target: `${request.packageId}::blink::redeem_voucher`,
+        typeArguments: [request.coinType],
+        arguments: [
+            tx.object(request.escrowObject),
+            tx.pure.vector("u8", hexBytes(request.id)),
+            tx.pure.address(request.referrer),
+            tx.pure.u64(request.amount),
+            tx.pure.vector("u8", hexBytes(request.signature)),
+        ],
+    });
+    return tx;
+};

package/dist/svm.d.ts

@@ -0,0 +1,36 @@
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { SvmSwapInstructions } from "./gen/blink/v1/api_pb.js";
+export declare const DEFAULT_SWAP_PROGRAMS: PublicKey[];
+export declare const isNativeSvmToken: (address: string) => boolean;
+export declare const svmBalance: (rpcUrl: string, token: string, owner: string) => Promise<bigint>;
+export interface SvmDepositRequest {
+    rpcUrl: string;
+    programId: string;
+    owner: string;
+    token: string;
+    amount: bigint;
+    quoteHash: string;
+    feePayer?: string;
+}
+export declare const resolveSwapPrograms: (chain: string, swap: SvmSwapInstructions, expectedSigner: string | undefined) => PublicKey[];
+export interface SvmSwapDepositRequest {
+    rpcUrl: string;
+    chain: string;
+    programId: string;
+    owner: string;
+    srcToken: string;
+    bridgeToken: string;
+    amount: bigint;
+    minBridgeOut: bigint;
+    quoteHash: string;
+    swap: SvmSwapInstructions;
+    swapProgramSigner?: string;
+}
+export interface SvmDepositInstructions {
+    instructions: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+}
+export declare const buildSvmSwapDepositInstructions: (request: SvmSwapDepositRequest) => Promise<SvmDepositInstructions>;
+export declare const buildSvmSwapDeposit: (request: SvmSwapDepositRequest) => Promise<Uint8Array>;
+export declare const buildSvmDepositInstructions: (request: SvmDepositRequest) => Promise<TransactionInstruction[]>;
+export declare const buildSvmDeposit: (request: SvmDepositRequest) => Promise<Uint8Array>;