bpay

BPay is a broadly used Australian bill payment system. http://www.bpay.com.au


The system uses check digits with a sort of 'mix and match' 'Check Digit Rule Name' to select the checkdigit algorithm.

This is of the format "WxxMyyyFza" where Wxx indicates the key of an entry in a weights table

Myyy indicates the key of an entry in a modulus table

Fz indicates the key of an entry in a flags table

a, which must only be specified for Modulus 11 check digits, indicates the translations required for check digit values 10 and 11.

BPay recommends the check digit rule: W01M101F3 (MOD10V01) for billers who don't already have a preferred method. This happens to be the same algorithm used for many credit cards and other systems - the Luhn Algorithm or 'mod 10 algorithm'.

--- Below is a *minimally tested* tcl8.5 package to return and test BPay checkdigits.

Save it as bpaycheckdigit-0.2.tm and place it on your module path (see output of [tcl::tm::list])

    synopsis:
    %package require bpaycheckdigit
    0.2
    %bpaycheckdigit::get  2007050100001
    1
    %bpaycheckdigit::test 20070501000012
    0
    %bpaycheckdigit::test 20070501000011
    1
    %bpaycheckdigit::get  2007050100001   W17M971F1
    49
    %bpaycheckdigit::test 200705010000149 W17M971F1
    1
    %bpaycheckdigit::test 200705010500149 W17M971F1
    0

    WARNING: This has not been properly tested, reviewed or used in a production environment.
    You should review the code, and USE AT YOUR OWN RISK.
    In particular - weights array member 19 may need to be extended to contain further powers of 2
    to support larger inputs (or better; the code adjusted to extrapolate values)
    Also - this work was done by working from an old bpay document.
    Things may have changed, comments/updates welcome.
    According to this wikipedia article: http://en.wikipedia.org/wiki/Luhn_algorithm
    the Luhn Algorithm itself is public domain.
    The package supplied here is also released as public domain.

 #jmn 2007-05
 package require Tcl 8.5  ;#require 8.5 features such as lreverse, in

 package provide bpaycheckdigit [namespace eval bpaycheckdigit {
        variable version 0.2

        set version
 }]

 proc bpaycheckdigit::init {} {
        variable weights
        variable modulii
        variable flags
        variable translations
        

        set weights(01,array) {1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2}
        set weights(01,maxdigits) ""

        set weights(02,array) {2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1}
        set weights(02,maxdigits) ""

        set weights(03,array) {2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 0 0 0}
        set weights(03,maxdigits) ""

        set weights(04,array) {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}
        set weights(04,maxdigits) ""

        set weights(05,array) {20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1}
        set weights(05,maxdigits) ""

        set weights(06,array) {2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21}
        set weights(06,maxdigits) ""

        set weights(07,array) {21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2}
        set weights(07,maxdigits) ""

        set weights(08,array) {2 1 7 4 5 3 2 1 7 4 5 3 2 1 7 4 5 3 2 1}
        set weights(08,maxdigits) ""

        set weights(09,array) {3 2 7 6 5 4 3 2 7 6 5 4 3 2 7 6 5 4 3 2}
        set weights(09,maxdigits) ""

        set weights(10,array) {3 2 9 8 7 4 3 2 9 8 7 4 3 2 9 8 7 4 3 2}
        set weights(10,maxdigits) ""


        set weights(11,array) {3 5 2 4 6 1 3 5 2 4 6 1 3 5 2 4 6 1 3 5}
        set weights(11,maxdigits) ""

        set weights(12,array) {3 7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7}
        set weights(12,maxdigits) ""

        set weights(13,array) {6 2 7 5 3 2 8 6 2 7 5 3 2 8 6 2 7 5 3 2}
        set weights(13,maxdigits) ""

        set weights(14,array) {7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7 1 3 7 1}
        set weights(14,maxdigits) ""

        set weights(15,array) {9 7 3 1 9 7 3 1 9 7 3 1 9 7 3 1 9 7 3 1}
        set weights(15,maxdigits) ""

        set weights(16,array) {9 7 5 3 1 9 7 5 3 1 9 7 5 3 1 9 7 5 3 1}
        set weights(16,maxdigits) ""

        set weights(17,array) {20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 2 1 4 3}
        set weights(17,maxdigits) ""

        set weights(18,array) {39 37 35 33 31 29 27 25 23 21 19 17 15 13 11 9 7 5 3 1}
        set weights(18,maxdigits) ""

        set weights(19,array) {1024 512 256 128 64 32 16 8 4 2}
        set weights(19,maxdigits) ""

        set weights(20,array) {0 0 5 2 7 4 3}
        set weights(20,maxdigits) "7"

        set weights(21,array) {0 0 7 6 9 2 3}
        set weights(21,maxdigits) "7"

        set weights(22,array) {0 0 11 3 7 19 13}
        set weights(22,maxdigits) "7"

        set weights(23,array) {5 8 4 2 1 6 3 7}
        set weights(23,maxdigits) "8"

        set weights(24,array) {6 9 7 5 3 8 4 2}
        set weights(24,maxdigits) "8"

        set weights(25,array) {0 0 15 17 12 13 07 18 14 3}
        set weights(25,maxdigits) "10"

        set weights(26,array) {0 0 7 1 3 9 1 7 9 1 3 7 9 1}
        set weights(26,maxdigits) "14"

        set weights(27,array) {1 6 7 2 9 4}
        set weights(27,maxdigits) "6"

        set weights(28,array) {7 9 10 5 8 4 2}
        set weights(28,maxdigits) "7"

        set weights(29,array) {3 9 7 3 1 7 5 3 1}
        set weights(29,maxdigits) "9"

        set weights(30,array) {13 11 7 5 3 2 1 13 11 7 5 3 2 1 13 11 7 5 3 2}
        set weights(30,maxdigits) ""

        set weights(31,array) {10 7 8 4 6 3 5 2}
        set weights(31,maxdigits) "8"

        set weights(32,array) {17 13 3 5 7}
        set weights(32,maxdigits) "5"


        set mlist {
        090 9         0        1
        091 9         9        1
        100 10        0        1
        101        10        10        1
        102        10        9        1
        103        10        17        1
        110        11        0        1
        111        11        11        1
        112        11        0        1
        113        11        0        1
        130        13        0        2
        131        13        13        2
        132        13        61        2
        970        97        00        2
        971        97        97        2
        }
        foreach {num divideby subtractfrom cdlength} $mlist {
                set modulii($num,divideby) $divideby
                set modulii($num,subtractfrom) $subtractfrom
                set modulii($num,cdlength) $cdlength
        }


        set flist {
        0        N        N        N
        1        N        N        Y
        2        N        Y        N
        3        N        Y        Y
        4        N        T        N
        5        N        T        Y
        6        Y        N        N
        7        Y        N        Y
        8        Y        Y        N
        9        Y        Y        Y
        }
        foreach {num start_left add_digits keep_zero} $flist {
                set flags($num,start_left)        $start_left
                set flags($num,add_digits)        $add_digits
                set flags($num,keep_zero)        $keep_zero
        }

        set tlist {
        a        ""        ""
        b        ""        0
        c        ""        1
        d        0        ""
        e        0        1
        f        0        10
        g        1        ""
        h        1        0
        i        1        10
        j        11        0
        k        11        1
        l        11        10
        }
        foreach {name cd10 cd11} $tlist {
                set translations($name,cd10) $cd10
                set translations($name,cd11) $cd11
        }

 }

 # cdrule format WxxMyyyFza
 # (a optional)
 #e.g cdrule -> W17M971F1
 #return a dict containing rule values required by algorithm
 proc bpaycheckdigit::getrule {cdrule} {
        variable weights
        variable modulii
        variable flags
        variable translations

        set cdrule [string trim $cdrule]
        if {![string length $cdrule]} {
                error "empty rule string supplied"
        }
        if {[string length $cdrule] ni {9 10}} {
                error "expected rule string of format WxxMyyyFz or WxxMyyyFza"
        }


        set w [string tolower [string index $cdrule 0]]
        if {$w ne "w"} {
                error "bad rule string: expected firstchar 'w'"
        }                
        set weight [string range $cdrule 1 2]
        
        set m [string tolower [string index $cdrule 3]]
        if {$m ne "m"} {
                error "bad rule string: expected 'm' at char index 3"
        }
        set modulus [string range $cdrule 4 6]
        
        set f [string tolower [string index $cdrule 7]]
        if {$f ne "f"} {
                error "bad rule string: expected 'f' at char index 7"
        }
        set flag [string index $cdrule 8]

        set translation ""
        if {[string length $cdrule] == 10} {
                set translation [string index $cdrule 9]
        }

        set result [list weight $weight modulus $modulus flag $flag translation $translation]

        dict set result weightarray $weights($weight,array)
        if {![string length $weights($weight,maxdigits)]} {
                dict set result maxdigits [llength $weights($weight,array)]
        } else {
                dict set result maxdigits $weights($weight,maxdigits)
        }

        
        dict set result divideby                 $modulii($modulus,divideby)
        dict set result subtractfrom        $modulii($modulus,subtractfrom)
        dict set result cdlength                $modulii($modulus,cdlength)

        dict set result startleft                $flags($flag,start_left)
        dict set result adddigits                $flags($flag,add_digits)
        dict set result keepzero                $flags($flag,keep_zero)

        if {[string length $translation]} {
                dict set result cd10                         $translations($translation,cd10)
                dict set result cd11                        $translations($translation,cd11)
        } else {
                dict set result cd10 ""
                dict set result cd11 ""
        }

        return $result
 }

 proc bpaycheckdigit::test {completenumber {cdrule W01M101F3}} {
        set rule [getrule $cdrule]
        set cdlength [dict get $rule cdlength]
        set refnumber [string range $completenumber 0 end-$cdlength]
        if {[string length $refnumber] > [dict get $rule maxdigits]} {
                error "number is longer than maxdigits specified by the supplied rule"
        }
                
        set cd [string range $completenumber end-[expr {$cdlength - 1}] end]
        
        if {$cd eq [bpaycheckdigit::get $refnumber $cdrule]} {
                return 1
        } else {
                return 0
        }
 }

 proc bpaycheckdigit::get {refnumber {cdrule W01M101F3}} {
        #rule recommended by bpay for billers that haven't currently got a check digit routine.
        #W01M101F3 = MOD10V01 (STANDARD LUHNS MODULUS 10)
        #(also works for visa/mastercard)

        set rule [getrule $cdrule]
        if {[string length $refnumber] > [dict get $rule maxdigits]} {
                error "number is longer than maxdigits specified by the supplied rule"
        }
        
        set refdigits [split $refnumber {}]
        if {[string tolower [dict get $rule startleft]] eq "n"} {
                set refdigits [lreverse $refdigits]
                set weights [lreverse [dict get $rule weightarray]]
        } else {
                set weights [dict get $rule weightarray]
        }
        set adddigits [string tolower [dict get $rule adddigits]]
        set keepzero [string tolower [dict get $rule keepzero]]

        set cd 0
        set i 0
        foreach ref $refdigits wt $weights {
                set weighted [expr {$wt * $ref}]
                if {$weighted > 9} {
                        if {$adddigits eq "y"} {
                                set weighted [expr [join [split $weighted {}] +]]  ;#not fastest way to sum a list.. but should be fine here.
                        } elseif {$adddigits eq "t"} {
                                set weighted [string index $weighted end] ;#(efficiency warning: will shimmer)
                        }
                }
                incr cd $weighted
                incr i
                if {$i >= [llength $refdigits]} {
                        break
                }
        }

        set divideby [dict get $rule divideby]
        set subtractfrom [dict get $rule subtractfrom]
        set cd10 [dict get $rule cd10]
        set cd11 [dict get $rule cd11]
        set cdlength [dict get $rule cdlength]


        set cd [expr {$cd % $divideby}]

        if {($cd != 0) && ($subtractfrom != 0)} {
                set cd [expr {$subtractfrom - $cd}]
        } elseif {($cd == 0) && !$keepzero} {
                set cd $subtractfrom
        }

        set cd [expr {abs($cd)}]

        if {($cd == 10) && [string length $cd10]} {
                set cd $cd10
        } elseif {($cd == 11) && [string length $cd11]} {
                set cd $cd11
        }

        if {($cdlength == 2) && ([string length $cd] == 1)} {
                set cd "0$cd"
        } 

        return $cd
 }

 bpaycheckdigit::init