Transactions

import { BitBadgesSigningClient, GenericCosmosAdapter, MsgTransferTokens } from 'bitbadges';

const adapter = await GenericCosmosAdapter.fromKeplr('bitbadges-1');
const client = new BitBadgesSigningClient({ adapter });

// Send bob one unit of token ID 1 from collection 1
const result = await client.signAndBroadcast([
  new MsgTransferTokens({
    creator: client.address,
    collectionId: '1',
    transfers: [
      {
        from: client.address,
        toAddresses: ['bb1py4mfpg6uf59qkyzg0nmau322c5873eeysp5ue'],
        balances: [{ amount: '1', tokenIds: [{ start: '1', end: '1' }], ownershipTimes: [{ start: '1', end: '18446744073709551615' }] }]
      }
    ]
  })
]);
console.log(result.txHash);

import { BitBadgesAPI, BigIntify, MsgTransferTokens, createTransactionPayload, createTxBroadcastBody, type TxContext } from 'bitbadges';

const api = new BitBadgesAPI({ convertFunction: BigIntify, apiKey: process.env.BITBADGES_API_KEY }); // key from https://bitbadges.io/developer
const ALICE = 'bb1p0rrel3365scadq5k9pv0x0zp9j22js6dnw70d';
const BOB = 'bb1py4mfpg6uf59qkyzg0nmau322c5873eeysp5ue';

// 1. Build messages
const msgs = [
  new MsgTransferTokens({
    creator: ALICE,
    collectionId: '1',
    transfers: [
      {
        from: ALICE,
        toAddresses: [BOB],
        balances: [{ amount: '1', tokenIds: [{ start: '1', end: '1' }], ownershipTimes: [{ start: '1', end: '18446744073709551615' }] }]
      }
    ]
  })
];

// 2. Transaction context (account number, sequence, public key, fee)
const { account } = await api.getAccount({ address: ALICE });
const txContext: TxContext = {
  sender: {
    address: account.address,
    sequence: account.sequence ?? 0n,
    accountNumber: account.accountNumber,
    publicKey: account.publicKey
  },
  fee: { amount: '0', denom: 'ubadge', gas: '400000' },
  memo: ''
};

// 3. Payload to sign
const payload = createTransactionPayload(txContext, msgs);

// 4. Sign (Keplr shown; see sign-cosmos and sign-ethereum for the other wallets)
await window.keplr!.enable('bitbadges-1');
const signed = await window.keplr!.signDirect(
  'bitbadges-1',
  ALICE,
  {
    bodyBytes: payload.signDirect.body.toBinary(),
    authInfoBytes: payload.signDirect.authInfo.toBinary(),
    chainId: 'bitbadges-1',
    accountNumber: BigInt(String(account.accountNumber)) as any
  },
  { preferNoSetFee: true }
);
const hexSignature = Buffer.from(signed.signature.signature, 'base64').toString('hex');

// 5. Broadcast body, then simulate or broadcast
const txBody = createTxBroadcastBody(txContext, msgs, hexSignature);
const sim = await api.simulateTx(txBody);
const res = await api.broadcastTx(txBody);
console.log(sim.gas_info.gas_used, res.tx_response.txhash);

import { MsgCreateCollection, MsgTransferTokens, proto } from 'bitbadges';

// SDK classes: generic over NumberType, have toProto()
const sdkMsg = new MsgTransferTokens<bigint>({
  creator: 'bb1p0rrel3365scadq5k9pv0x0zp9j22js6dnw70d',
  collectionId: 1n,
  transfers: [
    {
      from: 'bb1p0rrel3365scadq5k9pv0x0zp9j22js6dnw70d',
      toAddresses: ['bb1py4mfpg6uf59qkyzg0nmau322c5873eeysp5ue'],
      balances: [{ amount: 1n, tokenIds: [{ start: 1n, end: 1n }], ownershipTimes: [{ start: 1n, end: 18446744073709551615n }] }]
    }
  ]
});

// Proto classes: what the chain encodes; numbers are strings
const protoMsg = new proto.tokenization.MsgDeleteCollection({ creator: 'bb1p0rrel3365scadq5k9pv0x0zp9j22js6dnw70d', collectionId: '1' });

import { BitBadgesAPI, BigIntify, type TxContext } from 'bitbadges';

const api = new BitBadgesAPI({ convertFunction: BigIntify, apiKey: process.env.BITBADGES_API_KEY });
const { account } = await api.getAccount({ address: 'bb1p0rrel3365scadq5k9pv0x0zp9j22js6dnw70d' });

if (BigInt(account.accountNumber) <= 0n) {
  // Unregistered: the chain has never seen this address, so it cannot verify a signature from it.
  // Register it by sending any non-zero amount of any denom (BADGE works) from a registered key,
  // then fetch the account again.
  throw new Error(`Account ${account.address} is unregistered. Fund it and re-fetch before building a tx context.`);
}

const txContext: TxContext = {
  // Optional: chainIdOverride: 'bitbadges-1'
  sender: {
    address: account.address, // native bb1 form
    sequence: account.sequence ?? 0n, // string or bigint, never Number()
    accountNumber: account.accountNumber,
    publicKey: account.publicKey // base64; required for Cosmos signatures, '' for EVM
  },
  fee: { amount: '0', denom: 'ubadge', gas: '400000' },
  memo: '',
  // Optional: set evmAddress to also get an EVM precompile call in the payload
  evmAddress: '0x0bc63cfe31d5218eb414b142c799e20964a54a1a'
};

const getPublicKey = async () => {
  const key = await window.keplr?.getKey('bitbadges-1');
  return key ? Buffer.from(key.pubKey).toString('base64') : '';
};

const gasLimit = (BigInt(gasUsed) * 13n + 9n) / 10n; // 30% buffer, rounded up
if (gasLimit < 1n || gasLimit > 100000000n) throw new Error("Invalid gas limit");
const feeInUbadge = gasLimit * 10n;
txContext.fee = { gas: gasLimit.toString(), amount: feeInUbadge.toString(), denom: "ubadge" };

import { createTransactionPayload } from 'bitbadges';

const payload = createTransactionPayload(txContext, msgs);

interface TransactionPayload {
  signDirect: { body: TxBody; authInfo: AuthInfo; signBytes: string }; // present when sender is set
  legacyAmino: { body: TxBody; authInfo: AuthInfo; signBytes: string }; // present when sender is set
  evmTx?: {
    to: string; // precompile address: 0x0000000000000000000000000000000000001001 tokenization, 0x0000000000000000000000000000000000001002 gamm, 0x0000000000000000000000000000000000001003 sendmanager
    data: string; // ABI-encoded call data
    value: string; // always "0"
    functionName: string; // for logging
  };
}