@luffalab/luffa-endless-sdk v1.1.7

SDK for Luffa Endless Wallet

Install

npm install @luffalab/luffa-endless-sdk npm install @endlesslab/endless-ts-sdk

Usage

import {
  Network,
  EntryFunctionABI,
  TypeTagAddress,
  TypeTagU128,
  AccountAddress,
  EndlessConfig,
  Endless,
  AccountAuthenticator
} from '@endlesslab/endless-ts-sdk'

import {
  EndlessLuffaSdk,
  UserResponseStatus,
  EndlessSignAndSubmitTransactionInput,
  EndlessWalletTransactionType,
  EndLessSDKEvent,
} from '@luffalab/luffa-endless-sdk';

const jssdk = new EndlessLuffaSdk({
  // mainnet or testnet
  network: 'testnet',
});

const connectWalletHandler = async () => {
  const connectRes = await jssdk.connect();
  if (connectRes.status === UserResponseStatus.APPROVED) {
  console.log('connectRes =====>', connectRes.args.account);
}
};

const disconnectWalletHandler = () => {
  jssdk.disconnect().then(() => {
    console.log('disconnect success');
  });
};

const getAccountHandler = async () => {
  const getAccountRes = await jssdk.getAccount();

  if (getAccountRes.status === UserResponseStatus.APPROVED) {
    console.log('getAccountRes =====>', getAccountRes.args.account);
  }
};

const signMessageHandler = async () => {
  if (!signMessage || !accountAddress) {
    return;
  }

  const signMessageRes = await jssdk.signMessage({ message: signMessage });

  if (signMessageRes.status === UserResponseStatus.APPROVED) {
    setSignature(signMessageRes.args.signature.toString());
  }
};

const signAndSubmitTrancactionHandler = async () => {
  if (!accountAddress) {
    alert('please connect wallet');
    return;
  }

  if (!toAccountAddress || !transferAmount) {
    alert('please input toAccountAddress and transferAmount');
    return;
  }

  const transferEDSAbi: EntryFunctionABI = {
    typeParameters: [],
    parameters: [new TypeTagAddress(), new TypeTagU128()],
  };

  const transferData: EndlessSignAndSubmitTransactionInput = {
    payload: {
      function: '0x1::endless_account::transfer',
      functionArguments: [
        AccountAddress.fromBs58String(toAccountAddress),
        BigInt(parseInt(transferAmount) * 100000000),
      ],
      abi: transferEDSAbi,
    },
  };

  const transactionRes = await jssdk.signAndSubmitTransaction(transferData);
  if (transactionRes.status === UserResponseStatus.APPROVED) {
    console.log('signAndSubmitTransaction transactionRes =====>', transactionRes);
  }
};

const signTrancactionHandler = async () => {
  const config = new EndlessConfig({
    network: Network.TESTNET
  })
  const endless = new Endless(config)
  if (!accountAddress) {
    alert('please connect wallet');
    return;
  }

  const transferData: EndlessSignAndSubmitTransactionInput = {
    payload: {
      function: '0x1::endless_account::transfer',
      functionArguments: [
        AccountAddress.fromBs58String(toAccountAddress),
        BigInt(parseInt(transferAmount) * 100000000),
      ],
      abi: transferEDSAbi,
    },
  };

  const txn = await endless.transaction.build.simple({
    sender: accountAddress,
    data: transferData.payload
  });
  // EndlessWalletTransactionType.MULTI_AGENT
  const transactionRes = await jssdk.signTransaction(txn, EndlessWalletTransactionType.SIMPLE);
  if (transactionRes.status === UserResponseStatus.APPROVED) {
    console.log('signTransaction transactionRes =====>', transactionRes);
    const data = Hex.fromHexString(transactionRes.args.data).toUint8Array();
    const deserializer = new Deserializer(data);
    const txnRes = AccountAuthenticator.deserialize(deserializer);
    console.log('AccountAuthenticator deserializer', txnRes);
  }
};

jssdk.on(EndLessSDKEvent.CONNECT, (res) => {
  console.log('connect', res);
});

const disconnectHandler = () => {
  console.log('disconnect');
}
jssdk.on(EndLessSDKEvent.DISCONNECT, disconnectHandler);
jssdk.off(EndLessSDKEvent.DISCONNECT, disconnectHandler);